BENCH: convert bencmarks to asv format

remove files that were part of the origal repo
rework randomgen docs to integrate with numpy and fix some links
remove convenience functions, require explicit call to gen.brng
move code out of numpy.random.randomgen into numpy.random

100 files changed, 16834 insertions, 0 deletions

diff --git a/numpy/random/src/aligned_malloc/aligned_malloc.c b/numpy/random/src/aligned_malloc/aligned_malloc.c
new file mode 100644
index 000000000..6e8192cfb
--- /dev/null
+++ b/numpy/random/src/aligned_malloc/aligned_malloc.c
@@ -0,0 +1,9 @@
+#include "aligned_malloc.h"
+
+static NPY_INLINE void *PyArray_realloc_aligned(void *p, size_t n);
+
+static NPY_INLINE void *PyArray_malloc_aligned(size_t n);
+
+static NPY_INLINE void *PyArray_calloc_aligned(size_t n, size_t s);
+
+static NPY_INLINE void PyArray_free_aligned(void *p);
\ No newline at end of file
diff --git a/numpy/random/src/aligned_malloc/aligned_malloc.h b/numpy/random/src/aligned_malloc/aligned_malloc.h
new file mode 100644
index 000000000..ea24f6d23
--- /dev/null
+++ b/numpy/random/src/aligned_malloc/aligned_malloc.h
@@ -0,0 +1,54 @@
+#ifndef _RANDOMDGEN__ALIGNED_MALLOC_H_
+#define _RANDOMDGEN__ALIGNED_MALLOC_H_
+
+#include "Python.h"
+#include "numpy/npy_common.h"
+
+#define NPY_MEMALIGN 16 /* 16 for SSE2, 32 for AVX, 64 for Xeon Phi */
+
+static NPY_INLINE void *PyArray_realloc_aligned(void *p, size_t n)
+{
+    void *p1, **p2, *base;
+    size_t old_offs, offs = NPY_MEMALIGN - 1 + sizeof(void *);
+    if (NPY_UNLIKELY(p != NULL))
+    {
+        base = *(((void **)p) - 1);
+        if (NPY_UNLIKELY((p1 = PyMem_Realloc(base, n + offs)) == NULL))
+            return NULL;
+        if (NPY_LIKELY(p1 == base))
+            return p;
+        p2 = (void **)(((Py_uintptr_t)(p1) + offs) & ~(NPY_MEMALIGN - 1));
+        old_offs = (size_t)((Py_uintptr_t)p - (Py_uintptr_t)base);
+        memmove((void *)p2, ((char *)p1) + old_offs, n);
+    }
+    else
+    {
+        if (NPY_UNLIKELY((p1 = PyMem_Malloc(n + offs)) == NULL))
+            return NULL;
+        p2 = (void **)(((Py_uintptr_t)(p1) + offs) & ~(NPY_MEMALIGN - 1));
+    }
+    *(p2 - 1) = p1;
+    return (void *)p2;
+}
+
+static NPY_INLINE void *PyArray_malloc_aligned(size_t n)
+{
+    return PyArray_realloc_aligned(NULL, n);
+}
+
+static NPY_INLINE void *PyArray_calloc_aligned(size_t n, size_t s)
+{
+    void *p;
+    if (NPY_UNLIKELY((p = PyArray_realloc_aligned(NULL, n * s)) == NULL))
+        return NULL;
+    memset(p, 0, n * s);
+    return p;
+}
+
+static NPY_INLINE void PyArray_free_aligned(void *p)
+{
+    void *base = *(((void **)p) - 1);
+    PyMem_Free(base);
+}
+
+#endif
diff --git a/numpy/random/src/common/LICENSE.md b/numpy/random/src/common/LICENSE.md
new file mode 100644
index 000000000..71bf8cf46
--- /dev/null
+++ b/numpy/random/src/common/LICENSE.md
@@ -0,0 +1,29 @@
+ISO C9x  compliant stdint.h for Microsoft Visual Studio
+Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+
+Copyright (c) 2006-2013 Alexander Chemeris
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the product nor the names of its contributors may
+ be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
diff --git a/numpy/random/src/common/inttypes.h b/numpy/random/src/common/inttypes.h
new file mode 100644
index 000000000..8f8b61108
--- /dev/null
+++ b/numpy/random/src/common/inttypes.h
@@ -0,0 +1,306 @@
+// ISO C9x  compliant inttypes.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+//  Copyright (c) 2006-2013 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_INTTYPES_H_ // [
+#define _MSC_INTTYPES_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include "stdint.h"
+
+// 7.8 Format conversion of integer types
+
+typedef struct {
+   intmax_t quot;
+   intmax_t rem;
+} imaxdiv_t;
+
+// 7.8.1 Macros for format specifiers
+
+#if !defined(__cplusplus) || defined(__STDC_FORMAT_MACROS) // [   See footnote 185 at page 198
+
+// The fprintf macros for signed integers are:
+#define PRId8       "d"
+#define PRIi8       "i"
+#define PRIdLEAST8  "d"
+#define PRIiLEAST8  "i"
+#define PRIdFAST8   "d"
+#define PRIiFAST8   "i"
+
+#define PRId16       "hd"
+#define PRIi16       "hi"
+#define PRIdLEAST16  "hd"
+#define PRIiLEAST16  "hi"
+#define PRIdFAST16   "hd"
+#define PRIiFAST16   "hi"
+
+#define PRId32       "I32d"
+#define PRIi32       "I32i"
+#define PRIdLEAST32  "I32d"
+#define PRIiLEAST32  "I32i"
+#define PRIdFAST32   "I32d"
+#define PRIiFAST32   "I32i"
+
+#define PRId64       "I64d"
+#define PRIi64       "I64i"
+#define PRIdLEAST64  "I64d"
+#define PRIiLEAST64  "I64i"
+#define PRIdFAST64   "I64d"
+#define PRIiFAST64   "I64i"
+
+#define PRIdMAX     "I64d"
+#define PRIiMAX     "I64i"
+
+#define PRIdPTR     "Id"
+#define PRIiPTR     "Ii"
+
+// The fprintf macros for unsigned integers are:
+#define PRIo8       "o"
+#define PRIu8       "u"
+#define PRIx8       "x"
+#define PRIX8       "X"
+#define PRIoLEAST8  "o"
+#define PRIuLEAST8  "u"
+#define PRIxLEAST8  "x"
+#define PRIXLEAST8  "X"
+#define PRIoFAST8   "o"
+#define PRIuFAST8   "u"
+#define PRIxFAST8   "x"
+#define PRIXFAST8   "X"
+
+#define PRIo16       "ho"
+#define PRIu16       "hu"
+#define PRIx16       "hx"
+#define PRIX16       "hX"
+#define PRIoLEAST16  "ho"
+#define PRIuLEAST16  "hu"
+#define PRIxLEAST16  "hx"
+#define PRIXLEAST16  "hX"
+#define PRIoFAST16   "ho"
+#define PRIuFAST16   "hu"
+#define PRIxFAST16   "hx"
+#define PRIXFAST16   "hX"
+
+#define PRIo32       "I32o"
+#define PRIu32       "I32u"
+#define PRIx32       "I32x"
+#define PRIX32       "I32X"
+#define PRIoLEAST32  "I32o"
+#define PRIuLEAST32  "I32u"
+#define PRIxLEAST32  "I32x"
+#define PRIXLEAST32  "I32X"
+#define PRIoFAST32   "I32o"
+#define PRIuFAST32   "I32u"
+#define PRIxFAST32   "I32x"
+#define PRIXFAST32   "I32X"
+
+#define PRIo64       "I64o"
+#define PRIu64       "I64u"
+#define PRIx64       "I64x"
+#define PRIX64       "I64X"
+#define PRIoLEAST64  "I64o"
+#define PRIuLEAST64  "I64u"
+#define PRIxLEAST64  "I64x"
+#define PRIXLEAST64  "I64X"
+#define PRIoFAST64   "I64o"
+#define PRIuFAST64   "I64u"
+#define PRIxFAST64   "I64x"
+#define PRIXFAST64   "I64X"
+
+#define PRIoMAX     "I64o"
+#define PRIuMAX     "I64u"
+#define PRIxMAX     "I64x"
+#define PRIXMAX     "I64X"
+
+#define PRIoPTR     "Io"
+#define PRIuPTR     "Iu"
+#define PRIxPTR     "Ix"
+#define PRIXPTR     "IX"
+
+// The fscanf macros for signed integers are:
+#define SCNd8       "d"
+#define SCNi8       "i"
+#define SCNdLEAST8  "d"
+#define SCNiLEAST8  "i"
+#define SCNdFAST8   "d"
+#define SCNiFAST8   "i"
+
+#define SCNd16       "hd"
+#define SCNi16       "hi"
+#define SCNdLEAST16  "hd"
+#define SCNiLEAST16  "hi"
+#define SCNdFAST16   "hd"
+#define SCNiFAST16   "hi"
+
+#define SCNd32       "ld"
+#define SCNi32       "li"
+#define SCNdLEAST32  "ld"
+#define SCNiLEAST32  "li"
+#define SCNdFAST32   "ld"
+#define SCNiFAST32   "li"
+
+#define SCNd64       "I64d"
+#define SCNi64       "I64i"
+#define SCNdLEAST64  "I64d"
+#define SCNiLEAST64  "I64i"
+#define SCNdFAST64   "I64d"
+#define SCNiFAST64   "I64i"
+
+#define SCNdMAX     "I64d"
+#define SCNiMAX     "I64i"
+
+#ifdef _WIN64 // [
+#  define SCNdPTR     "I64d"
+#  define SCNiPTR     "I64i"
+#else  // _WIN64 ][
+#  define SCNdPTR     "ld"
+#  define SCNiPTR     "li"
+#endif  // _WIN64 ]
+
+// The fscanf macros for unsigned integers are:
+#define SCNo8       "o"
+#define SCNu8       "u"
+#define SCNx8       "x"
+#define SCNX8       "X"
+#define SCNoLEAST8  "o"
+#define SCNuLEAST8  "u"
+#define SCNxLEAST8  "x"
+#define SCNXLEAST8  "X"
+#define SCNoFAST8   "o"
+#define SCNuFAST8   "u"
+#define SCNxFAST8   "x"
+#define SCNXFAST8   "X"
+
+#define SCNo16       "ho"
+#define SCNu16       "hu"
+#define SCNx16       "hx"
+#define SCNX16       "hX"
+#define SCNoLEAST16  "ho"
+#define SCNuLEAST16  "hu"
+#define SCNxLEAST16  "hx"
+#define SCNXLEAST16  "hX"
+#define SCNoFAST16   "ho"
+#define SCNuFAST16   "hu"
+#define SCNxFAST16   "hx"
+#define SCNXFAST16   "hX"
+
+#define SCNo32       "lo"
+#define SCNu32       "lu"
+#define SCNx32       "lx"
+#define SCNX32       "lX"
+#define SCNoLEAST32  "lo"
+#define SCNuLEAST32  "lu"
+#define SCNxLEAST32  "lx"
+#define SCNXLEAST32  "lX"
+#define SCNoFAST32   "lo"
+#define SCNuFAST32   "lu"
+#define SCNxFAST32   "lx"
+#define SCNXFAST32   "lX"
+
+#define SCNo64       "I64o"
+#define SCNu64       "I64u"
+#define SCNx64       "I64x"
+#define SCNX64       "I64X"
+#define SCNoLEAST64  "I64o"
+#define SCNuLEAST64  "I64u"
+#define SCNxLEAST64  "I64x"
+#define SCNXLEAST64  "I64X"
+#define SCNoFAST64   "I64o"
+#define SCNuFAST64   "I64u"
+#define SCNxFAST64   "I64x"
+#define SCNXFAST64   "I64X"
+
+#define SCNoMAX     "I64o"
+#define SCNuMAX     "I64u"
+#define SCNxMAX     "I64x"
+#define SCNXMAX     "I64X"
+
+#ifdef _WIN64 // [
+#  define SCNoPTR     "I64o"
+#  define SCNuPTR     "I64u"
+#  define SCNxPTR     "I64x"
+#  define SCNXPTR     "I64X"
+#else  // _WIN64 ][
+#  define SCNoPTR     "lo"
+#  define SCNuPTR     "lu"
+#  define SCNxPTR     "lx"
+#  define SCNXPTR     "lX"
+#endif  // _WIN64 ]
+
+#endif // __STDC_FORMAT_MACROS ]
+
+// 7.8.2 Functions for greatest-width integer types
+
+// 7.8.2.1 The imaxabs function
+#define imaxabs _abs64
+
+// 7.8.2.2 The imaxdiv function
+
+// This is modified version of div() function from Microsoft's div.c found
+// in %MSVC.NET%\crt\src\div.c
+#ifdef STATIC_IMAXDIV // [
+static
+#else // STATIC_IMAXDIV ][
+_inline
+#endif // STATIC_IMAXDIV ]
+imaxdiv_t __cdecl imaxdiv(intmax_t numer, intmax_t denom)
+{
+   imaxdiv_t result;
+
+   result.quot = numer / denom;
+   result.rem = numer % denom;
+
+   if (numer < 0 && result.rem > 0) {
+      // did division wrong; must fix up
+      ++result.quot;
+      result.rem -= denom;
+   }
+
+   return result;
+}
+
+// 7.8.2.3 The strtoimax and strtoumax functions
+#define strtoimax _strtoi64
+#define strtoumax _strtoui64
+
+// 7.8.2.4 The wcstoimax and wcstoumax functions
+#define wcstoimax _wcstoi64
+#define wcstoumax _wcstoui64
+
+
+#endif // _MSC_INTTYPES_H_ ]
\ No newline at end of file
diff --git a/numpy/random/src/common/stdint.h b/numpy/random/src/common/stdint.h
new file mode 100644
index 000000000..710de1570
--- /dev/null
+++ b/numpy/random/src/common/stdint.h
@@ -0,0 +1,258 @@
+// ISO C9x  compliant stdint.h for Microsoft Visual Studio
+// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+//
+//  Copyright (c) 2006-2013 Alexander Chemeris
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//   1. Redistributions of source code must retain the above copyright notice,
+//      this list of conditions and the following disclaimer.
+//
+//   2. Redistributions in binary form must reproduce the above copyright
+//      notice, this list of conditions and the following disclaimer in the
+//      documentation and/or other materials provided with the distribution.
+//
+//   3. Neither the name of the product nor the names of its contributors may
+//      be used to endorse or promote products derived from this software
+//      without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+// EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _MSC_VER // [
+#error "Use this header only with Microsoft Visual C++ compilers!"
+#endif // _MSC_VER ]
+
+#ifndef _MSC_STDINT_H_ // [
+#define _MSC_STDINT_H_
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#if _MSC_VER >= 1600 // [
+#include <stdint.h>
+#else // ] _MSC_VER >= 1600 [
+
+#include <limits.h>
+
+// For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+// compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
+// or compiler give many errors like this:
+//   error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <wchar.h>
+#ifdef __cplusplus
+}
+#endif
+
+// Define _W64 macros to mark types changing their size, like intptr_t.
+#ifndef _W64
+#if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#define _W64 __w64
+#else
+#define _W64
+#endif
+#endif
+
+// 7.18.1 Integer types
+
+// 7.18.1.1 Exact-width integer types
+
+// Visual Studio 6 and Embedded Visual C++ 4 doesn't
+// realize that, e.g. char has the same size as __int8
+// so we give up on __intX for them.
+#if (_MSC_VER < 1300)
+typedef signed char int8_t;
+typedef signed short int16_t;
+typedef signed int int32_t;
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+#else
+typedef signed __int8 int8_t;
+typedef signed __int16 int16_t;
+typedef signed __int32 int32_t;
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int16 uint16_t;
+typedef unsigned __int32 uint32_t;
+#endif
+typedef signed __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+
+// 7.18.1.2 Minimum-width integer types
+typedef int8_t int_least8_t;
+typedef int16_t int_least16_t;
+typedef int32_t int_least32_t;
+typedef int64_t int_least64_t;
+typedef uint8_t uint_least8_t;
+typedef uint16_t uint_least16_t;
+typedef uint32_t uint_least32_t;
+typedef uint64_t uint_least64_t;
+
+// 7.18.1.3 Fastest minimum-width integer types
+typedef int8_t int_fast8_t;
+typedef int16_t int_fast16_t;
+typedef int32_t int_fast32_t;
+typedef int64_t int_fast64_t;
+typedef uint8_t uint_fast8_t;
+typedef uint16_t uint_fast16_t;
+typedef uint32_t uint_fast32_t;
+typedef uint64_t uint_fast64_t;
+
+// 7.18.1.4 Integer types capable of holding object pointers
+#ifdef _WIN64 // [
+typedef signed __int64 intptr_t;
+typedef unsigned __int64 uintptr_t;
+#else         // _WIN64 ][
+typedef _W64 signed int intptr_t;
+typedef _W64 unsigned int uintptr_t;
+#endif        // _WIN64 ]
+
+// 7.18.1.5 Greatest-width integer types
+typedef int64_t intmax_t;
+typedef uint64_t uintmax_t;
+
+// 7.18.2 Limits of specified-width integer types
+
+#if !defined(__cplusplus) ||                                                   \
+    defined(__STDC_LIMIT_MACROS) // [   See footnote 220 at page 257 and
+                                 // footnote 221 at page 259
+
+// 7.18.2.1 Limits of exact-width integer types
+#define INT8_MIN ((int8_t)_I8_MIN)
+#define INT8_MAX _I8_MAX
+#define INT16_MIN ((int16_t)_I16_MIN)
+#define INT16_MAX _I16_MAX
+#define INT32_MIN ((int32_t)_I32_MIN)
+#define INT32_MAX _I32_MAX
+#define INT64_MIN ((int64_t)_I64_MIN)
+#define INT64_MAX _I64_MAX
+#define UINT8_MAX _UI8_MAX
+#define UINT16_MAX _UI16_MAX
+#define UINT32_MAX _UI32_MAX
+#define UINT64_MAX _UI64_MAX
+
+// 7.18.2.2 Limits of minimum-width integer types
+#define INT_LEAST8_MIN INT8_MIN
+#define INT_LEAST8_MAX INT8_MAX
+#define INT_LEAST16_MIN INT16_MIN
+#define INT_LEAST16_MAX INT16_MAX
+#define INT_LEAST32_MIN INT32_MIN
+#define INT_LEAST32_MAX INT32_MAX
+#define INT_LEAST64_MIN INT64_MIN
+#define INT_LEAST64_MAX INT64_MAX
+#define UINT_LEAST8_MAX UINT8_MAX
+#define UINT_LEAST16_MAX UINT16_MAX
+#define UINT_LEAST32_MAX UINT32_MAX
+#define UINT_LEAST64_MAX UINT64_MAX
+
+// 7.18.2.3 Limits of fastest minimum-width integer types
+#define INT_FAST8_MIN INT8_MIN
+#define INT_FAST8_MAX INT8_MAX
+#define INT_FAST16_MIN INT16_MIN
+#define INT_FAST16_MAX INT16_MAX
+#define INT_FAST32_MIN INT32_MIN
+#define INT_FAST32_MAX INT32_MAX
+#define INT_FAST64_MIN INT64_MIN
+#define INT_FAST64_MAX INT64_MAX
+#define UINT_FAST8_MAX UINT8_MAX
+#define UINT_FAST16_MAX UINT16_MAX
+#define UINT_FAST32_MAX UINT32_MAX
+#define UINT_FAST64_MAX UINT64_MAX
+
+// 7.18.2.4 Limits of integer types capable of holding object pointers
+#ifdef _WIN64 // [
+#define INTPTR_MIN INT64_MIN
+#define INTPTR_MAX INT64_MAX
+#define UINTPTR_MAX UINT64_MAX
+#else // _WIN64 ][
+#define INTPTR_MIN INT32_MIN
+#define INTPTR_MAX INT32_MAX
+#define UINTPTR_MAX UINT32_MAX
+#endif // _WIN64 ]
+
+// 7.18.2.5 Limits of greatest-width integer types
+#define INTMAX_MIN INT64_MIN
+#define INTMAX_MAX INT64_MAX
+#define UINTMAX_MAX UINT64_MAX
+
+// 7.18.3 Limits of other integer types
+
+#ifdef _WIN64 // [
+#define PTRDIFF_MIN _I64_MIN
+#define PTRDIFF_MAX _I64_MAX
+#else // _WIN64 ][
+#define PTRDIFF_MIN _I32_MIN
+#define PTRDIFF_MAX _I32_MAX
+#endif // _WIN64 ]
+
+#define SIG_ATOMIC_MIN INT_MIN
+#define SIG_ATOMIC_MAX INT_MAX
+
+#ifndef SIZE_MAX // [
+#ifdef _WIN64    // [
+#define SIZE_MAX _UI64_MAX
+#else // _WIN64 ][
+#define SIZE_MAX _UI32_MAX
+#endif            // _WIN64 ]
+#endif            // SIZE_MAX ]
+
+// WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h>
+#ifndef WCHAR_MIN // [
+#define WCHAR_MIN 0
+#endif            // WCHAR_MIN ]
+#ifndef WCHAR_MAX // [
+#define WCHAR_MAX _UI16_MAX
+#endif // WCHAR_MAX ]
+
+#define WINT_MIN 0
+#define WINT_MAX _UI16_MAX
+
+#endif // __STDC_LIMIT_MACROS ]
+
+// 7.18.4 Limits of other integer types
+
+#if !defined(__cplusplus) ||                                                   \
+    defined(__STDC_CONSTANT_MACROS) // [   See footnote 224 at page 260
+
+// 7.18.4.1 Macros for minimum-width integer constants
+
+#define INT8_C(val) val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val) val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+// 7.18.4.2 Macros for greatest-width integer constants
+// These #ifndef's are needed to prevent collisions with <boost/cstdint.hpp>.
+// Check out Issue 9 for the details.
+#ifndef INTMAX_C //   [
+#define INTMAX_C INT64_C
+#endif            // INTMAX_C    ]
+#ifndef UINTMAX_C //  [
+#define UINTMAX_C UINT64_C
+#endif // UINTMAX_C   ]
+
+#endif // __STDC_CONSTANT_MACROS ]
+
+#endif // _MSC_VER >= 1600 ]
+
+#endif // _MSC_STDINT_H_ ]
\ No newline at end of file
diff --git a/numpy/random/src/distributions/LICENSE.md b/numpy/random/src/distributions/LICENSE.md
new file mode 100644
index 000000000..31576ba4b
--- /dev/null
+++ b/numpy/random/src/distributions/LICENSE.md
@@ -0,0 +1,61 @@
+## NumPy
+
+Copyright (c) 2005-2017, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+
+* Neither the name of the NumPy Developers nor the names of any
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## Julia
+
+The ziggurat methods were derived from Julia.
+
+Copyright (c) 2009-2019: Jeff Bezanson, Stefan Karpinski, Viral B. Shah,
+and other contributors:
+
+https://github.com/JuliaLang/julia/contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/numpy/random/src/distributions/binomial.h b/numpy/random/src/distributions/binomial.h
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/numpy/random/src/distributions/binomial.h
diff --git a/numpy/random/src/distributions/distributions.c b/numpy/random/src/distributions/distributions.c
new file mode 100644
index 000000000..83806de38
--- /dev/null
+++ b/numpy/random/src/distributions/distributions.c
@@ -0,0 +1,1811 @@
+#include "distributions.h"
+#include "ziggurat.h"
+#include "ziggurat_constants.h"
+
+#if defined(_MSC_VER) && defined(_WIN64)
+#include <intrin.h>
+#endif
+
+/* Random generators for external use */
+float random_float(brng_t *brng_state) {
+  return next_float(brng_state);
+}
+
+double random_double(brng_t *brng_state) {
+  return next_double(brng_state);
+}
+
+static NPY_INLINE double next_standard_exponential(brng_t *brng_state) {
+  return -log(1.0 - next_double(brng_state));
+}
+
+double random_standard_exponential(brng_t *brng_state) {
+  return next_standard_exponential(brng_state);
+}
+
+void random_standard_exponential_fill(brng_t *brng_state, npy_intp cnt,
+                                      double *out) {
+  npy_intp i;
+  for (i = 0; i < cnt; i++) {
+    out[i] = next_standard_exponential(brng_state);
+  }
+}
+
+float random_standard_exponential_f(brng_t *brng_state) {
+  return -logf(1.0f - next_float(brng_state));
+}
+
+void random_double_fill(brng_t *brng_state, npy_intp cnt, double *out) {
+  npy_intp i;
+  for (i = 0; i < cnt; i++) {
+    out[i] = next_double(brng_state);
+  }
+}
+#if 0
+double random_gauss(brng_t *brng_state) {
+  if (brng_state->has_gauss) {
+    const double temp = brng_state->gauss;
+    brng_state->has_gauss = false;
+    brng_state->gauss = 0.0;
+    return temp;
+  } else {
+    double f, x1, x2, r2;
+
+    do {
+      x1 = 2.0 * next_double(brng_state) - 1.0;
+      x2 = 2.0 * next_double(brng_state) - 1.0;
+      r2 = x1 * x1 + x2 * x2;
+    } while (r2 >= 1.0 || r2 == 0.0);
+
+    /* Polar method, a more efficient version of the Box-Muller approach. */
+    f = sqrt(-2.0 * log(r2) / r2);
+    /* Keep for next call */
+    brng_state->gauss = f * x1;
+    brng_state->has_gauss = true;
+    return f * x2;
+  }
+}
+
+float random_gauss_f(brng_t *brng_state) {
+  if (brng_state->has_gauss_f) {
+    const float temp = brng_state->gauss_f;
+    brng_state->has_gauss_f = false;
+    brng_state->gauss_f = 0.0f;
+    return temp;
+  } else {
+    float f, x1, x2, r2;
+
+    do {
+      x1 = 2.0f * next_float(brng_state) - 1.0f;
+      x2 = 2.0f * next_float(brng_state) - 1.0f;
+      r2 = x1 * x1 + x2 * x2;
+    } while (r2 >= 1.0 || r2 == 0.0);
+
+    /* Polar method, a more efficient version of the Box-Muller approach. */
+    f = sqrtf(-2.0f * logf(r2) / r2);
+    /* Keep for next call */
+    brng_state->gauss_f = f * x1;
+    brng_state->has_gauss_f = true;
+    return f * x2;
+  }
+}
+#endif
+
+static NPY_INLINE double standard_exponential_zig(brng_t *brng_state);
+
+static double standard_exponential_zig_unlikely(brng_t *brng_state, uint8_t idx,
+                                                double x) {
+  if (idx == 0) {
+    return ziggurat_exp_r - log(next_double(brng_state));
+  } else if ((fe_double[idx - 1] - fe_double[idx]) * next_double(brng_state) +
+                 fe_double[idx] <
+             exp(-x)) {
+    return x;
+  } else {
+    return standard_exponential_zig(brng_state);
+  }
+}
+
+static NPY_INLINE double standard_exponential_zig(brng_t *brng_state) {
+  uint64_t ri;
+  uint8_t idx;
+  double x;
+  ri = next_uint64(brng_state);
+  ri >>= 3;
+  idx = ri & 0xFF;
+  ri >>= 8;
+  x = ri * we_double[idx];
+  if (ri < ke_double[idx]) {
+    return x; /* 98.9% of the time we return here 1st try */
+  }
+  return standard_exponential_zig_unlikely(brng_state, idx, x);
+}
+
+double random_standard_exponential_zig(brng_t *brng_state) {
+  return standard_exponential_zig(brng_state);
+}
+
+void random_standard_exponential_zig_fill(brng_t *brng_state, npy_intp cnt,
+                                          double *out) {
+  npy_intp i;
+  for (i = 0; i < cnt; i++) {
+    out[i] = standard_exponential_zig(brng_state);
+  }
+}
+
+static NPY_INLINE float standard_exponential_zig_f(brng_t *brng_state);
+
+static float standard_exponential_zig_unlikely_f(brng_t *brng_state,
+                                                 uint8_t idx, float x) {
+  if (idx == 0) {
+    return ziggurat_exp_r_f - logf(next_float(brng_state));
+  } else if ((fe_float[idx - 1] - fe_float[idx]) * next_float(brng_state) +
+                 fe_float[idx] <
+             expf(-x)) {
+    return x;
+  } else {
+    return standard_exponential_zig_f(brng_state);
+  }
+}
+
+static NPY_INLINE float standard_exponential_zig_f(brng_t *brng_state) {
+  uint32_t ri;
+  uint8_t idx;
+  float x;
+  ri = next_uint32(brng_state);
+  ri >>= 1;
+  idx = ri & 0xFF;
+  ri >>= 8;
+  x = ri * we_float[idx];
+  if (ri < ke_float[idx]) {
+    return x; /* 98.9% of the time we return here 1st try */
+  }
+  return standard_exponential_zig_unlikely_f(brng_state, idx, x);
+}
+
+float random_standard_exponential_zig_f(brng_t *brng_state) {
+  return standard_exponential_zig_f(brng_state);
+}
+
+static NPY_INLINE double next_gauss_zig(brng_t *brng_state) {
+  uint64_t r;
+  int sign;
+  int64_t rabs;
+  int idx;
+  double x, xx, yy;
+  for (;;) {
+    /* r = e3n52sb8 */
+    r = next_uint64(brng_state);
+    idx = r & 0xff;
+    r >>= 8;
+    sign = r & 0x1;
+    rabs = (int64_t)((r >> 1) & 0x000fffffffffffff);
+    x = rabs * wi_double[idx];
+    if (sign & 0x1)
+      x = -x;
+    if (rabs < ki_double[idx])
+      return x; /* 99.3% of the time return here */
+    if (idx == 0) {
+      for (;;) {
+        xx = -ziggurat_nor_inv_r * log(next_double(brng_state));
+        yy = -log(next_double(brng_state));
+        if (yy + yy > xx * xx)
+          return ((rabs >> 8) & 0x1) ? -(ziggurat_nor_r + xx)
+                                     : ziggurat_nor_r + xx;
+      }
+    } else {
+      if (((fi_double[idx - 1] - fi_double[idx]) * next_double(brng_state) +
+           fi_double[idx]) < exp(-0.5 * x * x))
+        return x;
+    }
+  }
+}
+
+double random_gauss_zig(brng_t *brng_state) {
+  return next_gauss_zig(brng_state);
+}
+
+void random_gauss_zig_fill(brng_t *brng_state, npy_intp cnt, double *out) {
+  npy_intp i;
+  for (i = 0; i < cnt; i++) {
+    out[i] = next_gauss_zig(brng_state);
+  }
+}
+
+float random_gauss_zig_f(brng_t *brng_state) {
+  uint32_t r;
+  int sign;
+  int32_t rabs;
+  int idx;
+  float x, xx, yy;
+  for (;;) {
+    /* r = n23sb8 */
+    r = next_uint32(brng_state);
+    idx = r & 0xff;
+    sign = (r >> 8) & 0x1;
+    rabs = (int32_t)((r >> 9) & 0x0007fffff);
+    x = rabs * wi_float[idx];
+    if (sign & 0x1)
+      x = -x;
+    if (rabs < ki_float[idx])
+      return x; /* # 99.3% of the time return here */
+    if (idx == 0) {
+      for (;;) {
+        xx = -ziggurat_nor_inv_r_f * logf(next_float(brng_state));
+        yy = -logf(next_float(brng_state));
+        if (yy + yy > xx * xx)
+          return ((rabs >> 8) & 0x1) ? -(ziggurat_nor_r_f + xx)
+                                     : ziggurat_nor_r_f + xx;
+      }
+    } else {
+      if (((fi_float[idx - 1] - fi_float[idx]) * next_float(brng_state) +
+           fi_float[idx]) < exp(-0.5 * x * x))
+        return x;
+    }
+  }
+}
+
+/*
+static NPY_INLINE double standard_gamma(brng_t *brng_state, double shape) {
+  double b, c;
+  double U, V, X, Y;
+
+  if (shape == 1.0) {
+    return random_standard_exponential(brng_state);
+  } else if (shape < 1.0) {
+    for (;;) {
+      U = next_double(brng_state);
+      V = random_standard_exponential(brng_state);
+      if (U <= 1.0 - shape) {
+        X = pow(U, 1. / shape);
+        if (X <= V) {
+          return X;
+        }
+      } else {
+        Y = -log((1 - U) / shape);
+        X = pow(1.0 - shape + shape * Y, 1. / shape);
+        if (X <= (V + Y)) {
+          return X;
+        }
+      }
+    }
+  } else {
+    b = shape - 1. / 3.;
+    c = 1. / sqrt(9 * b);
+    for (;;) {
+      do {
+        X = random_gauss(brng_state);
+        V = 1.0 + c * X;
+      } while (V <= 0.0);
+
+      V = V * V * V;
+      U = next_double(brng_state);
+      if (U < 1.0 - 0.0331 * (X * X) * (X * X))
+        return (b * V);
+      if (log(U) < 0.5 * X * X + b * (1. - V + log(V)))
+        return (b * V);
+    }
+  }
+}
+
+static NPY_INLINE float standard_gamma_float(brng_t *brng_state, float shape) {
+  float b, c;
+  float U, V, X, Y;
+
+  if (shape == 1.0f) {
+    return random_standard_exponential_f(brng_state);
+  } else if (shape < 1.0f) {
+    for (;;) {
+      U = next_float(brng_state);
+      V = random_standard_exponential_f(brng_state);
+      if (U <= 1.0f - shape) {
+        X = powf(U, 1.0f / shape);
+        if (X <= V) {
+          return X;
+        }
+      } else {
+        Y = -logf((1.0f - U) / shape);
+        X = powf(1.0f - shape + shape * Y, 1.0f / shape);
+        if (X <= (V + Y)) {
+          return X;
+        }
+      }
+    }
+  } else {
+    b = shape - 1.0f / 3.0f;
+    c = 1.0f / sqrtf(9.0f * b);
+    for (;;) {
+      do {
+        X = random_gauss_f(brng_state);
+        V = 1.0f + c * X;
+      } while (V <= 0.0f);
+
+      V = V * V * V;
+      U = next_float(brng_state);
+      if (U < 1.0f - 0.0331f * (X * X) * (X * X))
+        return (b * V);
+      if (logf(U) < 0.5f * X * X + b * (1.0f - V + logf(V)))
+        return (b * V);
+    }
+  }
+}
+
+
+double random_standard_gamma(brng_t *brng_state, double shape) {
+  return standard_gamma(brng_state, shape);
+}
+
+float random_standard_gamma_f(brng_t *brng_state, float shape) {
+  return standard_gamma_float(brng_state, shape);
+}
+*/
+
+static NPY_INLINE double standard_gamma_zig(brng_t *brng_state, double shape) {
+  double b, c;
+  double U, V, X, Y;
+
+  if (shape == 1.0) {
+    return random_standard_exponential_zig(brng_state);
+  } else if (shape == 0.0) {
+    return 0.0;
+  } else if (shape < 1.0) {
+    for (;;) {
+      U = next_double(brng_state);
+      V = random_standard_exponential_zig(brng_state);
+      if (U <= 1.0 - shape) {
+        X = pow(U, 1. / shape);
+        if (X <= V) {
+          return X;
+        }
+      } else {
+        Y = -log((1 - U) / shape);
+        X = pow(1.0 - shape + shape * Y, 1. / shape);
+        if (X <= (V + Y)) {
+          return X;
+        }
+      }
+    }
+  } else {
+    b = shape - 1. / 3.;
+    c = 1. / sqrt(9 * b);
+    for (;;) {
+      do {
+        X = random_gauss_zig(brng_state);
+        V = 1.0 + c * X;
+      } while (V <= 0.0);
+
+      V = V * V * V;
+      U = next_double(brng_state);
+      if (U < 1.0 - 0.0331 * (X * X) * (X * X))
+        return (b * V);
+      if (log(U) < 0.5 * X * X + b * (1. - V + log(V)))
+        return (b * V);
+    }
+  }
+}
+
+static NPY_INLINE float standard_gamma_zig_f(brng_t *brng_state, float shape) {
+  float b, c;
+  float U, V, X, Y;
+
+  if (shape == 1.0f) {
+    return random_standard_exponential_zig_f(brng_state);
+  } else if (shape == 0.0) {
+    return 0.0;
+  } else if (shape < 1.0f) {
+    for (;;) {
+      U = next_float(brng_state);
+      V = random_standard_exponential_zig_f(brng_state);
+      if (U <= 1.0f - shape) {
+        X = powf(U, 1.0f / shape);
+        if (X <= V) {
+          return X;
+        }
+      } else {
+        Y = -logf((1.0f - U) / shape);
+        X = powf(1.0f - shape + shape * Y, 1.0f / shape);
+        if (X <= (V + Y)) {
+          return X;
+        }
+      }
+    }
+  } else {
+    b = shape - 1.0f / 3.0f;
+    c = 1.0f / sqrtf(9.0f * b);
+    for (;;) {
+      do {
+        X = random_gauss_zig_f(brng_state);
+        V = 1.0f + c * X;
+      } while (V <= 0.0f);
+
+      V = V * V * V;
+      U = next_float(brng_state);
+      if (U < 1.0f - 0.0331f * (X * X) * (X * X))
+        return (b * V);
+      if (logf(U) < 0.5f * X * X + b * (1.0f - V + logf(V)))
+        return (b * V);
+    }
+  }
+}
+
+double random_standard_gamma_zig(brng_t *brng_state, double shape) {
+  return standard_gamma_zig(brng_state, shape);
+}
+
+float random_standard_gamma_zig_f(brng_t *brng_state, float shape) {
+  return standard_gamma_zig_f(brng_state, shape);
+}
+
+int64_t random_positive_int64(brng_t *brng_state) {
+  return next_uint64(brng_state) >> 1;
+}
+
+int32_t random_positive_int32(brng_t *brng_state) {
+  return next_uint32(brng_state) >> 1;
+}
+
+int64_t random_positive_int(brng_t *brng_state) {
+#if ULONG_MAX <= 0xffffffffUL
+  return (int64_t)(next_uint32(brng_state) >> 1);
+#else
+  return (int64_t)(next_uint64(brng_state) >> 1);
+#endif
+}
+
+uint64_t random_uint(brng_t *brng_state) {
+#if ULONG_MAX <= 0xffffffffUL
+  return next_uint32(brng_state);
+#else
+  return next_uint64(brng_state);
+#endif
+}
+
+/*
+ * log-gamma function to support some of these distributions. The
+ * algorithm comes from SPECFUN by Shanjie Zhang and Jianming Jin and their
+ * book "Computation of Special Functions", 1996, John Wiley & Sons, Inc.
+ */
+static double loggam(double x) {
+  double x0, x2, xp, gl, gl0;
+  int64_t k, n;
+
+  static double a[10] = {8.333333333333333e-02, -2.777777777777778e-03,
+                         7.936507936507937e-04, -5.952380952380952e-04,
+                         8.417508417508418e-04, -1.917526917526918e-03,
+                         6.410256410256410e-03, -2.955065359477124e-02,
+                         1.796443723688307e-01, -1.39243221690590e+00};
+  x0 = x;
+  n = 0;
+  if ((x == 1.0) || (x == 2.0)) {
+    return 0.0;
+  } else if (x <= 7.0) {
+    n = (int64_t)(7 - x);
+    x0 = x + n;
+  }
+  x2 = 1.0 / (x0 * x0);
+  xp = 2 * M_PI;
+  gl0 = a[9];
+  for (k = 8; k >= 0; k--) {
+    gl0 *= x2;
+    gl0 += a[k];
+  }
+  gl = gl0 / x0 + 0.5 * log(xp) + (x0 - 0.5) * log(x0) - x0;
+  if (x <= 7.0) {
+    for (k = 1; k <= n; k++) {
+      gl -= log(x0 - 1.0);
+      x0 -= 1.0;
+    }
+  }
+  return gl;
+}
+
+/*
+double random_normal(brng_t *brng_state, double loc, double scale) {
+  return loc + scale * random_gauss(brng_state);
+}
+*/
+
+double random_normal_zig(brng_t *brng_state, double loc, double scale) {
+  return loc + scale * random_gauss_zig(brng_state);
+}
+
+double random_exponential(brng_t *brng_state, double scale) {
+  return scale * standard_exponential_zig(brng_state);
+}
+
+double random_uniform(brng_t *brng_state, double lower, double range) {
+  return lower + range * next_double(brng_state);
+}
+
+double random_gamma(brng_t *brng_state, double shape, double scale) {
+  return scale * random_standard_gamma_zig(brng_state, shape);
+}
+
+float random_gamma_float(brng_t *brng_state, float shape, float scale) {
+  return scale * random_standard_gamma_zig_f(brng_state, shape);
+}
+
+double random_beta(brng_t *brng_state, double a, double b) {
+  double Ga, Gb;
+
+  if ((a <= 1.0) && (b <= 1.0)) {
+    double U, V, X, Y;
+    /* Use Johnk's algorithm */
+
+    while (1) {
+      U = next_double(brng_state);
+      V = next_double(brng_state);
+      X = pow(U, 1.0 / a);
+      Y = pow(V, 1.0 / b);
+
+      if ((X + Y) <= 1.0) {
+        if (X + Y > 0) {
+          return X / (X + Y);
+        } else {
+          double logX = log(U) / a;
+          double logY = log(V) / b;
+          double logM = logX > logY ? logX : logY;
+          logX -= logM;
+          logY -= logM;
+
+          return exp(logX - log(exp(logX) + exp(logY)));
+        }
+      }
+    }
+  } else {
+    Ga = random_standard_gamma_zig(brng_state, a);
+    Gb = random_standard_gamma_zig(brng_state, b);
+    return Ga / (Ga + Gb);
+  }
+}
+
+double random_chisquare(brng_t *brng_state, double df) {
+  return 2.0 * random_standard_gamma_zig(brng_state, df / 2.0);
+}
+
+double random_f(brng_t *brng_state, double dfnum, double dfden) {
+  return ((random_chisquare(brng_state, dfnum) * dfden) /
+          (random_chisquare(brng_state, dfden) * dfnum));
+}
+
+double random_standard_cauchy(brng_t *brng_state) {
+  return random_gauss_zig(brng_state) / random_gauss_zig(brng_state);
+}
+
+double random_pareto(brng_t *brng_state, double a) {
+  return exp(standard_exponential_zig(brng_state) / a) - 1;
+}
+
+double random_weibull(brng_t *brng_state, double a) {
+  if (a == 0.0) {
+    return 0.0;
+  }
+  return pow(standard_exponential_zig(brng_state), 1. / a);
+}
+
+double random_power(brng_t *brng_state, double a) {
+  return pow(1 - exp(-standard_exponential_zig(brng_state)), 1. / a);
+}
+
+double random_laplace(brng_t *brng_state, double loc, double scale) {
+  double U;
+
+  U = next_double(brng_state);
+  if (U < 0.5) {
+    U = loc + scale * log(U + U);
+  } else {
+    U = loc - scale * log(2.0 - U - U);
+  }
+  return U;
+}
+
+double random_gumbel(brng_t *brng_state, double loc, double scale) {
+  double U;
+
+  U = 1.0 - next_double(brng_state);
+  return loc - scale * log(-log(U));
+}
+
+double random_logistic(brng_t *brng_state, double loc, double scale) {
+  double U;
+
+  U = next_double(brng_state);
+  return loc + scale * log(U / (1.0 - U));
+}
+
+double random_lognormal(brng_t *brng_state, double mean, double sigma) {
+  return exp(random_normal_zig(brng_state, mean, sigma));
+}
+
+double random_rayleigh(brng_t *brng_state, double mode) {
+  return mode * sqrt(-2.0 * log(1.0 - next_double(brng_state)));
+}
+
+double random_standard_t(brng_t *brng_state, double df) {
+  double num, denom;
+
+  num = random_gauss_zig(brng_state);
+  denom = random_standard_gamma_zig(brng_state, df / 2);
+  return sqrt(df / 2) * num / sqrt(denom);
+}
+
+static int64_t random_poisson_mult(brng_t *brng_state, double lam) {
+  int64_t X;
+  double prod, U, enlam;
+
+  enlam = exp(-lam);
+  X = 0;
+  prod = 1.0;
+  while (1) {
+    U = next_double(brng_state);
+    prod *= U;
+    if (prod > enlam) {
+      X += 1;
+    } else {
+      return X;
+    }
+  }
+}
+
+/*
+ * The transformed rejection method for generating Poisson random variables
+ * W. Hoermann
+ * Insurance: Mathematics and Economics 12, 39-45 (1993)
+ */
+#define LS2PI 0.91893853320467267
+#define TWELFTH 0.083333333333333333333333
+static int64_t random_poisson_ptrs(brng_t *brng_state, double lam) {
+  int64_t k;
+  double U, V, slam, loglam, a, b, invalpha, vr, us;
+
+  slam = sqrt(lam);
+  loglam = log(lam);
+  b = 0.931 + 2.53 * slam;
+  a = -0.059 + 0.02483 * b;
+  invalpha = 1.1239 + 1.1328 / (b - 3.4);
+  vr = 0.9277 - 3.6224 / (b - 2);
+
+  while (1) {
+    U = next_double(brng_state) - 0.5;
+    V = next_double(brng_state);
+    us = 0.5 - fabs(U);
+    k = (int64_t)floor((2 * a / us + b) * U + lam + 0.43);
+    if ((us >= 0.07) && (V <= vr)) {
+      return k;
+    }
+    if ((k < 0) || ((us < 0.013) && (V > us))) {
+      continue;
+    }
+    if ((log(V) + log(invalpha) - log(a / (us * us) + b)) <=
+        (-lam + k * loglam - loggam(k + 1))) {
+      return k;
+    }
+  }
+}
+
+int64_t random_poisson(brng_t *brng_state, double lam) {
+  if (lam >= 10) {
+    return random_poisson_ptrs(brng_state, lam);
+  } else if (lam == 0) {
+    return 0;
+  } else {
+    return random_poisson_mult(brng_state, lam);
+  }
+}
+
+int64_t random_negative_binomial(brng_t *brng_state, double n, double p) {
+  double Y = random_gamma(brng_state, n, (1 - p) / p);
+  return random_poisson(brng_state, Y);
+}
+
+int64_t random_binomial_btpe(brng_t *brng_state, int64_t n, double p,
+                             binomial_t *binomial) {
+  double r, q, fm, p1, xm, xl, xr, c, laml, lamr, p2, p3, p4;
+  double a, u, v, s, F, rho, t, A, nrq, x1, x2, f1, f2, z, z2, w, w2, x;
+  int64_t m, y, k, i;
+
+  if (!(binomial->has_binomial) || (binomial->nsave != n) ||
+      (binomial->psave != p)) {
+    /* initialize */
+    binomial->nsave = n;
+    binomial->psave = p;
+    binomial->has_binomial = 1;
+    binomial->r = r = MIN(p, 1.0 - p);
+    binomial->q = q = 1.0 - r;
+    binomial->fm = fm = n * r + r;
+    binomial->m = m = (int64_t)floor(binomial->fm);
+    binomial->p1 = p1 = floor(2.195 * sqrt(n * r * q) - 4.6 * q) + 0.5;
+    binomial->xm = xm = m + 0.5;
+    binomial->xl = xl = xm - p1;
+    binomial->xr = xr = xm + p1;
+    binomial->c = c = 0.134 + 20.5 / (15.3 + m);
+    a = (fm - xl) / (fm - xl * r);
+    binomial->laml = laml = a * (1.0 + a / 2.0);
+    a = (xr - fm) / (xr * q);
+    binomial->lamr = lamr = a * (1.0 + a / 2.0);
+    binomial->p2 = p2 = p1 * (1.0 + 2.0 * c);
+    binomial->p3 = p3 = p2 + c / laml;
+    binomial->p4 = p4 = p3 + c / lamr;
+  } else {
+    r = binomial->r;
+    q = binomial->q;
+    fm = binomial->fm;
+    m = binomial->m;
+    p1 = binomial->p1;
+    xm = binomial->xm;
+    xl = binomial->xl;
+    xr = binomial->xr;
+    c = binomial->c;
+    laml = binomial->laml;
+    lamr = binomial->lamr;
+    p2 = binomial->p2;
+    p3 = binomial->p3;
+    p4 = binomial->p4;
+  }
+
+/* sigh ... */
+Step10:
+  nrq = n * r * q;
+  u = next_double(brng_state) * p4;
+  v = next_double(brng_state);
+  if (u > p1)
+    goto Step20;
+  y = (int64_t)floor(xm - p1 * v + u);
+  goto Step60;
+
+Step20:
+  if (u > p2)
+    goto Step30;
+  x = xl + (u - p1) / c;
+  v = v * c + 1.0 - fabs(m - x + 0.5) / p1;
+  if (v > 1.0)
+    goto Step10;
+  y = (int64_t)floor(x);
+  goto Step50;
+
+Step30:
+  if (u > p3)
+    goto Step40;
+  y = (int64_t)floor(xl + log(v) / laml);
+  if (y < 0)
+    goto Step10;
+  v = v * (u - p2) * laml;
+  goto Step50;
+
+Step40:
+  y = (int64_t)floor(xr - log(v) / lamr);
+  if (y > n)
+    goto Step10;
+  v = v * (u - p3) * lamr;
+
+Step50:
+  k = llabs(y - m);
+  if ((k > 20) && (k < ((nrq) / 2.0 - 1)))
+    goto Step52;
+
+  s = r / q;
+  a = s * (n + 1);
+  F = 1.0;
+  if (m < y) {
+    for (i = m + 1; i <= y; i++) {
+      F *= (a / i - s);
+    }
+  } else if (m > y) {
+    for (i = y + 1; i <= m; i++) {
+      F /= (a / i - s);
+    }
+  }
+  if (v > F)
+    goto Step10;
+  goto Step60;
+
+Step52:
+  rho =
+      (k / (nrq)) * ((k * (k / 3.0 + 0.625) + 0.16666666666666666) / nrq + 0.5);
+  t = -k * k / (2 * nrq);
+  A = log(v);
+  if (A < (t - rho))
+    goto Step60;
+  if (A > (t + rho))
+    goto Step10;
+
+  x1 = y + 1;
+  f1 = m + 1;
+  z = n + 1 - m;
+  w = n - y + 1;
+  x2 = x1 * x1;
+  f2 = f1 * f1;
+  z2 = z * z;
+  w2 = w * w;
+  if (A > (xm * log(f1 / x1) + (n - m + 0.5) * log(z / w) +
+           (y - m) * log(w * r / (x1 * q)) +
+           (13680. - (462. - (132. - (99. - 140. / f2) / f2) / f2) / f2) / f1 /
+               166320. +
+           (13680. - (462. - (132. - (99. - 140. / z2) / z2) / z2) / z2) / z /
+               166320. +
+           (13680. - (462. - (132. - (99. - 140. / x2) / x2) / x2) / x2) / x1 /
+               166320. +
+           (13680. - (462. - (132. - (99. - 140. / w2) / w2) / w2) / w2) / w /
+               166320.)) {
+    goto Step10;
+  }
+
+Step60:
+  if (p > 0.5) {
+    y = n - y;
+  }
+
+  return y;
+}
+
+int64_t random_binomial_inversion(brng_t *brng_state, int64_t n, double p,
+                                  binomial_t *binomial) {
+  double q, qn, np, px, U;
+  int64_t X, bound;
+
+  if (!(binomial->has_binomial) || (binomial->nsave != n) ||
+      (binomial->psave != p)) {
+    binomial->nsave = n;
+    binomial->psave = p;
+    binomial->has_binomial = 1;
+    binomial->q = q = 1.0 - p;
+    binomial->r = qn = exp(n * log(q));
+    binomial->c = np = n * p;
+    binomial->m = bound = (int64_t)MIN(n, np + 10.0 * sqrt(np * q + 1));
+  } else {
+    q = binomial->q;
+    qn = binomial->r;
+    np = binomial->c;
+    bound = binomial->m;
+  }
+  X = 0;
+  px = qn;
+  U = next_double(brng_state);
+  while (U > px) {
+    X++;
+    if (X > bound) {
+      X = 0;
+      px = qn;
+      U = next_double(brng_state);
+    } else {
+      U -= px;
+      px = ((n - X + 1) * p * px) / (X * q);
+    }
+  }
+  return X;
+}
+
+int64_t random_binomial(brng_t *brng_state, double p, int64_t n,
+                        binomial_t *binomial) {
+  double q;
+
+  if ((n == 0LL) || (p == 0.0f))
+    return 0;
+
+  if (p <= 0.5) {
+    if (p * n <= 30.0) {
+      return random_binomial_inversion(brng_state, n, p, binomial);
+    } else {
+      return random_binomial_btpe(brng_state, n, p, binomial);
+    }
+  } else {
+    q = 1.0 - p;
+    if (q * n <= 30.0) {
+      return n - random_binomial_inversion(brng_state, n, q, binomial);
+    } else {
+      return n - random_binomial_btpe(brng_state, n, q, binomial);
+    }
+  }
+}
+
+double random_noncentral_chisquare(brng_t *brng_state, double df, double nonc) {
+  if (npy_isnan(nonc)){
+    return NPY_NAN;
+  }
+  if (nonc == 0) {
+    return random_chisquare(brng_state, df);
+  }
+  if (1 < df) {
+    const double Chi2 = random_chisquare(brng_state, df - 1);
+    const double n = random_gauss_zig(brng_state) + sqrt(nonc);
+    return Chi2 + n * n;
+  } else {
+    const int64_t i = random_poisson(brng_state, nonc / 2.0);
+    return random_chisquare(brng_state, df + 2 * i);
+  }
+}
+
+double random_noncentral_f(brng_t *brng_state, double dfnum, double dfden,
+                           double nonc) {
+  double t = random_noncentral_chisquare(brng_state, dfnum, nonc) * dfden;
+  return t / (random_chisquare(brng_state, dfden) * dfnum);
+}
+
+double random_wald(brng_t *brng_state, double mean, double scale) {
+  double U, X, Y;
+  double mu_2l;
+
+  mu_2l = mean / (2 * scale);
+  Y = random_gauss_zig(brng_state);
+  Y = mean * Y * Y;
+  X = mean + mu_2l * (Y - sqrt(4 * scale * Y + Y * Y));
+  U = next_double(brng_state);
+  if (U <= mean / (mean + X)) {
+    return X;
+  } else {
+    return mean * mean / X;
+  }
+}
+
+double random_vonmises(brng_t *brng_state, double mu, double kappa) {
+  double s;
+  double U, V, W, Y, Z;
+  double result, mod;
+  int neg;
+  if (npy_isnan(kappa)){
+    return NPY_NAN;
+  }
+  if (kappa < 1e-8) {
+    return M_PI * (2 * next_double(brng_state) - 1);
+  } else {
+    /* with double precision rho is zero until 1.4e-8 */
+    if (kappa < 1e-5) {
+      /*
+       * second order taylor expansion around kappa = 0
+       * precise until relatively large kappas as second order is 0
+       */
+      s = (1. / kappa + kappa);
+    } else {
+      double r = 1 + sqrt(1 + 4 * kappa * kappa);
+      double rho = (r - sqrt(2 * r)) / (2 * kappa);
+      s = (1 + rho * rho) / (2 * rho);
+    }
+
+    while (1) {
+      U = next_double(brng_state);
+      Z = cos(M_PI * U);
+      W = (1 + s * Z) / (s + Z);
+      Y = kappa * (s - W);
+      V = next_double(brng_state);
+      if ((Y * (2 - Y) - V >= 0) || (log(Y / V) + 1 - Y >= 0)) {
+        break;
+      }
+    }
+
+    U = next_double(brng_state);
+
+    result = acos(W);
+    if (U < 0.5) {
+      result = -result;
+    }
+    result += mu;
+    neg = (result < 0);
+    mod = fabs(result);
+    mod = (fmod(mod + M_PI, 2 * M_PI) - M_PI);
+    if (neg) {
+      mod *= -1;
+    }
+
+    return mod;
+  }
+}
+
+int64_t random_logseries(brng_t *brng_state, double p) {
+  double q, r, U, V;
+  int64_t result;
+
+  r = log(1.0 - p);
+
+  while (1) {
+    V = next_double(brng_state);
+    if (V >= p) {
+      return 1;
+    }
+    U = next_double(brng_state);
+    q = 1.0 - exp(r * U);
+    if (V <= q * q) {
+      result = (int64_t)floor(1 + log(V) / log(q));
+      if (result < 1) {
+        continue;
+      } else {
+        return result;
+      }
+    }
+    if (V >= q) {
+      return 1;
+    }
+    return 2;
+  }
+}
+
+int64_t random_geometric_search(brng_t *brng_state, double p) {
+  double U;
+  int64_t X;
+  double sum, prod, q;
+
+  X = 1;
+  sum = prod = p;
+  q = 1.0 - p;
+  U = next_double(brng_state);
+  while (U > sum) {
+    prod *= q;
+    sum += prod;
+    X++;
+  }
+  return X;
+}
+
+int64_t random_geometric_inversion(brng_t *brng_state, double p) {
+  return (int64_t)ceil(log(1.0 - next_double(brng_state)) / log(1.0 - p));
+}
+
+int64_t random_geometric(brng_t *brng_state, double p) {
+  if (p >= 0.333333333333333333333333) {
+    return random_geometric_search(brng_state, p);
+  } else {
+    return random_geometric_inversion(brng_state, p);
+  }
+}
+
+int64_t random_zipf(brng_t *brng_state, double a) {
+  double T, U, V;
+  int64_t X;
+  double am1, b;
+
+  am1 = a - 1.0;
+  b = pow(2.0, am1);
+  do {
+    U = 1.0 - next_double(brng_state);
+    V = next_double(brng_state);
+    X = (int64_t)floor(pow(U, -1.0 / am1));
+    /* The real result may be above what can be represented in a int64.
+     * It will get casted to -sys.maxint-1. Since this is
+     * a straightforward rejection algorithm, we can just reject this value
+     * in the rejection condition below. This function then models a Zipf
+     * distribution truncated to sys.maxint.
+     */
+    T = pow(1.0 + 1.0 / X, am1);
+  } while (((V * X * (T - 1.0) / (b - 1.0)) > (T / b)) || X < 1);
+  return X;
+}
+
+double random_triangular(brng_t *brng_state, double left, double mode,
+                         double right) {
+  double base, leftbase, ratio, leftprod, rightprod;
+  double U;
+
+  base = right - left;
+  leftbase = mode - left;
+  ratio = leftbase / base;
+  leftprod = leftbase * base;
+  rightprod = (right - mode) * base;
+
+  U = next_double(brng_state);
+  if (U <= ratio) {
+    return left + sqrt(U * leftprod);
+  } else {
+    return right - sqrt((1.0 - U) * rightprod);
+  }
+}
+
+int64_t random_hypergeometric_hyp(brng_t *brng_state, int64_t good, int64_t bad,
+                                  int64_t sample) {
+  int64_t d1, k, z;
+  double d2, u, y;
+
+  d1 = bad + good - sample;
+  d2 = (double)MIN(bad, good);
+
+  y = d2;
+  k = sample;
+  while (y > 0.0) {
+    u = next_double(brng_state);
+    y -= (int64_t)floor(u + y / (d1 + k));
+    k--;
+    if (k == 0)
+      break;
+  }
+  z = (int64_t)(d2 - y);
+  if (good > bad)
+    z = sample - z;
+  return z;
+}
+
+/* D1 = 2*sqrt(2/e) */
+/* D2 = 3 - 2*sqrt(3/e) */
+#define D1 1.7155277699214135
+#define D2 0.8989161620588988
+int64_t random_hypergeometric_hrua(brng_t *brng_state, int64_t good,
+                                   int64_t bad, int64_t sample) {
+  int64_t mingoodbad, maxgoodbad, popsize, m, d9;
+  double d4, d5, d6, d7, d8, d10, d11;
+  int64_t Z;
+  double T, W, X, Y;
+
+  mingoodbad = MIN(good, bad);
+  popsize = good + bad;
+  maxgoodbad = MAX(good, bad);
+  m = MIN(sample, popsize - sample);
+  d4 = ((double)mingoodbad) / popsize;
+  d5 = 1.0 - d4;
+  d6 = m * d4 + 0.5;
+  d7 = sqrt((double)(popsize - m) * sample * d4 * d5 / (popsize - 1) + 0.5);
+  d8 = D1 * d7 + D2;
+  d9 = (int64_t)floor((double)(m + 1) * (mingoodbad + 1) / (popsize + 2));
+  d10 = (loggam(d9 + 1) + loggam(mingoodbad - d9 + 1) + loggam(m - d9 + 1) +
+         loggam(maxgoodbad - m + d9 + 1));
+  d11 = MIN(MIN(m, mingoodbad) + 1.0, floor(d6 + 16 * d7));
+  /* 16 for 16-decimal-digit precision in D1 and D2 */
+
+  while (1) {
+    X = next_double(brng_state);
+    Y = next_double(brng_state);
+    W = d6 + d8 * (Y - 0.5) / X;
+
+    /* fast rejection: */
+    if ((W < 0.0) || (W >= d11))
+      continue;
+
+    Z = (int64_t)floor(W);
+    T = d10 - (loggam(Z + 1) + loggam(mingoodbad - Z + 1) + loggam(m - Z + 1) +
+               loggam(maxgoodbad - m + Z + 1));
+
+    /* fast acceptance: */
+    if ((X * (4.0 - X) - 3.0) <= T)
+      break;
+
+    /* fast rejection: */
+    if (X * (X - T) >= 1)
+      continue;
+
+    if (2.0 * log(X) <= T)
+      break; /* acceptance */
+  }
+
+  /* this is a correction to HRUA* by Ivan Frohne in rv.py */
+  if (good > bad)
+    Z = m - Z;
+
+  /* another fix from rv.py to allow sample to exceed popsize/2 */
+  if (m < sample)
+    Z = good - Z;
+
+  return Z;
+}
+#undef D1
+#undef D2
+
+int64_t random_hypergeometric(brng_t *brng_state, int64_t good, int64_t bad,
+                              int64_t sample) {
+  if (sample > 10) {
+    return random_hypergeometric_hrua(brng_state, good, bad, sample);
+  } else {
+    return random_hypergeometric_hyp(brng_state, good, bad, sample);
+  }
+}
+
+uint64_t random_interval(brng_t *brng_state, uint64_t max) {
+  uint64_t mask, value;
+  if (max == 0) {
+    return 0;
+  }
+
+  mask = max;
+
+  /* Smallest bit mask >= max */
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+  mask |= mask >> 8;
+  mask |= mask >> 16;
+  mask |= mask >> 32;
+
+  /* Search a random value in [0..mask] <= max */
+  if (max <= 0xffffffffUL) {
+    while ((value = (next_uint32(brng_state) & mask)) > max)
+      ;
+  } else {
+    while ((value = (next_uint64(brng_state) & mask)) > max)
+      ;
+  }
+  return value;
+}
+
+static NPY_INLINE uint64_t gen_mask(uint64_t max) {
+  uint64_t mask = max;
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+  mask |= mask >> 8;
+  mask |= mask >> 16;
+  mask |= mask >> 32;
+  return mask;
+}
+
+/* Generate 16 bit random numbers using a 32 bit buffer. */
+static NPY_INLINE uint16_t buffered_uint16(brng_t *brng_state, int *bcnt,
+                                           uint32_t *buf) {
+  if (!(bcnt[0])) {
+    buf[0] = next_uint32(brng_state);
+    bcnt[0] = 1;
+  } else {
+    buf[0] >>= 16;
+    bcnt[0] -= 1;
+  }
+
+  return (uint16_t)buf[0];
+}
+
+/* Generate 8 bit random numbers using a 32 bit buffer. */
+static NPY_INLINE uint8_t buffered_uint8(brng_t *brng_state, int *bcnt,
+                                         uint32_t *buf) {
+  if (!(bcnt[0])) {
+    buf[0] = next_uint32(brng_state);
+    bcnt[0] = 3;
+  } else {
+    buf[0] >>= 8;
+    bcnt[0] -= 1;
+  }
+
+  return (uint8_t)buf[0];
+}
+
+/* Static `masked rejection` function called by random_bounded_uint64(...) */
+static NPY_INLINE uint64_t bounded_masked_uint64(brng_t *brng_state,
+                                                 uint64_t rng, uint64_t mask) {
+  uint64_t val;
+
+  while ((val = (next_uint64(brng_state) & mask)) > rng)
+    ;
+
+  return val;
+}
+
+/* Static `masked rejection` function called by
+ * random_buffered_bounded_uint32(...) */
+static NPY_INLINE uint32_t buffered_bounded_masked_uint32(
+    brng_t *brng_state, uint32_t rng, uint32_t mask, int *bcnt, uint32_t *buf) {
+  /*
+   * The buffer and buffer count are not used here but are included to allow
+   * this function to be templated with the similar uint8 and uint16
+   * functions
+   */
+
+  uint32_t val;
+
+  while ((val = (next_uint32(brng_state) & mask)) > rng)
+    ;
+
+  return val;
+}
+
+/* Static `masked rejection` function called by
+ * random_buffered_bounded_uint16(...) */
+static NPY_INLINE uint16_t buffered_bounded_masked_uint16(
+    brng_t *brng_state, uint16_t rng, uint16_t mask, int *bcnt, uint32_t *buf) {
+  uint16_t val;
+
+  while ((val = (buffered_uint16(brng_state, bcnt, buf) & mask)) > rng)
+    ;
+
+  return val;
+}
+
+/* Static `masked rejection` function called by
+ * random_buffered_bounded_uint8(...) */
+static NPY_INLINE uint8_t buffered_bounded_masked_uint8(brng_t *brng_state,
+                                                        uint8_t rng,
+                                                        uint8_t mask, int *bcnt,
+                                                        uint32_t *buf) {
+  uint8_t val;
+
+  while ((val = (buffered_uint8(brng_state, bcnt, buf) & mask)) > rng)
+    ;
+
+  return val;
+}
+
+/* Static `Lemire rejection` function called by random_bounded_uint64(...) */
+static NPY_INLINE uint64_t bounded_lemire_uint64(brng_t *brng_state,
+                                                 uint64_t rng) {
+  /*
+   * Uses Lemire's algorithm - https://arxiv.org/abs/1805.10941
+   *
+   * Note: `rng` should not be 0xFFFFFFFFFFFFFFFF. When this happens `rng_excl`
+   * becomes zero.
+   */
+  const uint64_t rng_excl = rng + 1;
+
+#if __SIZEOF_INT128__
+  /* 128-bit uint available (e.g. GCC/clang). `m` is the __uint128_t scaled
+   * integer. */
+  __uint128_t m;
+  uint64_t leftover;
+
+  /* Generate a scaled random number. */
+  m = ((__uint128_t)next_uint64(brng_state)) * rng_excl;
+
+  /* Rejection sampling to remove any bias. */
+  leftover = m & 0xFFFFFFFFFFFFFFFFULL;
+
+  if (leftover < rng_excl) {
+    /* `rng_excl` is a simple upper bound for `threshold`. */
+
+    const uint64_t threshold = -rng_excl % rng_excl;
+    /* Same as: threshold=((uint64_t)(0x10000000000000000ULLL - rng_excl)) %
+     * rng_excl; */
+
+    while (leftover < threshold) {
+      m = ((__uint128_t)next_uint64(brng_state)) * rng_excl;
+      leftover = m & 0xFFFFFFFFFFFFFFFFULL;
+    }
+  }
+
+  return (m >> 64);
+#else
+  /* 128-bit uint NOT available (e.g. MSVS). `m1` is the upper 64-bits of the
+   * scaled integer. */
+  uint64_t m1;
+  uint64_t x;
+  uint64_t leftover;
+
+  x = next_uint64(brng_state);
+
+  /* Rejection sampling to remove any bias. */
+  leftover = x * rng_excl; /* The lower 64-bits of the mult. */
+
+  if (leftover < rng_excl) {
+    /* `rng_excl` is a simple upper bound for `threshold`. */
+
+    const uint64_t threshold = -rng_excl % rng_excl;
+    /* Same as:threshold=((uint64_t)(0x10000000000000000ULLL - rng_excl)) %
+     * rng_excl; */
+
+    while (leftover < threshold) {
+      x = next_uint64(brng_state);
+      leftover = x * rng_excl;
+    }
+  }
+
+#if defined(_MSC_VER) && defined(_WIN64)
+  /* _WIN64 architecture. Use the __umulh intrinsic to calc `m1`. */
+  m1 = __umulh(x, rng_excl);
+#else
+  /* 32-bit architecture. Emulate __umulh to calc `m1`. */
+  {
+    uint64_t x0, x1, rng_excl0, rng_excl1;
+    uint64_t w0, w1, w2, t;
+
+    x0 = x & 0xFFFFFFFFULL;
+    x1 = x >> 32;
+    rng_excl0 = rng_excl & 0xFFFFFFFFULL;
+    rng_excl1 = rng_excl >> 32;
+    w0 = x0 * rng_excl0;
+    t = x1 * rng_excl0 + (w0 >> 32);
+    w1 = t & 0xFFFFFFFFULL;
+    w2 = t >> 32;
+    w1 += x0 * rng_excl1;
+    m1 = x1 * rng_excl1 + w2 + (w1 >> 32);
+  }
+#endif
+
+  return m1;
+#endif
+}
+
+/* Static `Lemire rejection` function called by
+ * random_buffered_bounded_uint32(...) */
+static NPY_INLINE uint32_t buffered_bounded_lemire_uint32(brng_t *brng_state,
+                                                          uint32_t rng,
+                                                          int *bcnt,
+                                                          uint32_t *buf) {
+  /*
+   * Uses Lemire's algorithm - https://arxiv.org/abs/1805.10941
+   *
+   * The buffer and buffer count are not used here but are included to allow
+   * this function to be templated with the similar uint8 and uint16
+   * functions
+   *
+   * Note: `rng` should not be 0xFFFFFFFF. When this happens `rng_excl` becomes
+   * zero.
+   */
+  const uint32_t rng_excl = rng + 1;
+
+  uint64_t m;
+  uint32_t leftover;
+
+  /* Generate a scaled random number. */
+  m = ((uint64_t)next_uint32(brng_state)) * rng_excl;
+
+  /* Rejection sampling to remove any bias */
+  leftover = m & 0xFFFFFFFFUL;
+
+  if (leftover < rng_excl) {
+    /* `rng_excl` is a simple upper bound for `threshold`. */
+    const uint32_t threshold = -rng_excl % rng_excl;
+    /* Same as: threshold=((uint64_t)(0x100000000ULL - rng_excl)) % rng_excl; */
+
+    while (leftover < threshold) {
+      m = ((uint64_t)next_uint32(brng_state)) * rng_excl;
+      leftover = m & 0xFFFFFFFFUL;
+    }
+  }
+
+  return (m >> 32);
+}
+
+/* Static `Lemire rejection` function called by
+ * random_buffered_bounded_uint16(...) */
+static NPY_INLINE uint16_t buffered_bounded_lemire_uint16(brng_t *brng_state,
+                                                          uint16_t rng,
+                                                          int *bcnt,
+                                                          uint32_t *buf) {
+  /*
+   * Uses Lemire's algorithm - https://arxiv.org/abs/1805.10941
+   *
+   * Note: `rng` should not be 0xFFFF. When this happens `rng_excl` becomes
+   * zero.
+   */
+  const uint16_t rng_excl = rng + 1;
+
+  uint32_t m;
+  uint16_t leftover;
+
+  /* Generate a scaled random number. */
+  m = ((uint32_t)buffered_uint16(brng_state, bcnt, buf)) * rng_excl;
+
+  /* Rejection sampling to remove any bias */
+  leftover = m & 0xFFFFUL;
+
+  if (leftover < rng_excl) {
+    /* `rng_excl` is a simple upper bound for `threshold`. */
+    const uint16_t threshold = -rng_excl % rng_excl;
+    /* Same as: threshold=((uint32_t)(0x10000ULL - rng_excl)) % rng_excl; */
+
+    while (leftover < threshold) {
+      m = ((uint32_t)buffered_uint16(brng_state, bcnt, buf)) * rng_excl;
+      leftover = m & 0xFFFFUL;
+    }
+  }
+
+  return (m >> 16);
+}
+
+/* Static `Lemire rejection` function called by
+ * random_buffered_bounded_uint8(...) */
+static NPY_INLINE uint8_t buffered_bounded_lemire_uint8(brng_t *brng_state,
+                                                        uint8_t rng, int *bcnt,
+                                                        uint32_t *buf) {
+  /*
+   * Uses Lemire's algorithm - https://arxiv.org/abs/1805.10941
+   *
+   * Note: `rng` should not be 0xFF. When this happens `rng_excl` becomes
+   * zero.
+   */
+  const uint8_t rng_excl = rng + 1;
+
+  uint16_t m;
+  uint8_t leftover;
+
+  /* Generate a scaled random number. */
+  m = ((uint16_t)buffered_uint8(brng_state, bcnt, buf)) * rng_excl;
+
+  /* Rejection sampling to remove any bias */
+  leftover = m & 0xFFUL;
+
+  if (leftover < rng_excl) {
+    /* `rng_excl` is a simple upper bound for `threshold`. */
+    const uint8_t threshold = -rng_excl % rng_excl;
+    /* Same as: threshold=((uint16_t)(0x100ULL - rng_excl)) % rng_excl; */
+
+    while (leftover < threshold) {
+      m = ((uint16_t)buffered_uint8(brng_state, bcnt, buf)) * rng_excl;
+      leftover = m & 0xFFUL;
+    }
+  }
+
+  return (m >> 8);
+}
+
+/*
+ * Returns a single random npy_uint64 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+uint64_t random_bounded_uint64(brng_t *brng_state, uint64_t off, uint64_t rng,
+                               uint64_t mask, bool use_masked) {
+  if (rng == 0) {
+    return off;
+  } else if (rng < 0xFFFFFFFFUL) {
+    /* Call 32-bit generator if range in 32-bit. */
+    if (use_masked) {
+      return off +
+             buffered_bounded_masked_uint32(brng_state, rng, mask, NULL, NULL);
+    } else {
+      return off + buffered_bounded_lemire_uint32(brng_state, rng, NULL, NULL);
+    }
+  } else if (rng == 0xFFFFFFFFFFFFFFFFULL) {
+    /* Lemire64 doesn't support inclusive rng = 0xFFFFFFFFFFFFFFFF. */
+    return off + next_uint64(brng_state);
+  } else {
+    if (use_masked) {
+      return off + bounded_masked_uint64(brng_state, rng, mask);
+    } else {
+      return off + bounded_lemire_uint64(brng_state, rng);
+    }
+  }
+}
+
+/*
+ * Returns a single random npy_uint64 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+uint32_t random_buffered_bounded_uint32(brng_t *brng_state, uint32_t off,
+                                        uint32_t rng, uint32_t mask,
+                                        bool use_masked, int *bcnt,
+                                        uint32_t *buf) {
+  /*
+   * Unused bcnt and buf are here only to allow templating with other uint
+   * generators.
+   */
+  if (rng == 0) {
+    return off;
+  } else if (rng == 0xFFFFFFFFUL) {
+    /* Lemire32 doesn't support inclusive rng = 0xFFFFFFFF. */
+    return off + next_uint32(brng_state);
+  } else {
+    if (use_masked) {
+      return off +
+             buffered_bounded_masked_uint32(brng_state, rng, mask, bcnt, buf);
+    } else {
+      return off + buffered_bounded_lemire_uint32(brng_state, rng, bcnt, buf);
+    }
+  }
+}
+
+/*
+ * Returns a single random npy_uint16 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+uint16_t random_buffered_bounded_uint16(brng_t *brng_state, uint16_t off,
+                                        uint16_t rng, uint16_t mask,
+                                        bool use_masked, int *bcnt,
+                                        uint32_t *buf) {
+  if (rng == 0) {
+    return off;
+  } else if (rng == 0xFFFFUL) {
+    /* Lemire16 doesn't support inclusive rng = 0xFFFF. */
+    return off + buffered_uint16(brng_state, bcnt, buf);
+  } else {
+    if (use_masked) {
+      return off +
+             buffered_bounded_masked_uint16(brng_state, rng, mask, bcnt, buf);
+    } else {
+      return off + buffered_bounded_lemire_uint16(brng_state, rng, bcnt, buf);
+    }
+  }
+}
+
+/*
+ * Returns a single random npy_uint8 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+uint8_t random_buffered_bounded_uint8(brng_t *brng_state, uint8_t off,
+                                      uint8_t rng, uint8_t mask,
+                                      bool use_masked, int *bcnt,
+                                      uint32_t *buf) {
+  if (rng == 0) {
+    return off;
+  } else if (rng == 0xFFUL) {
+    /* Lemire8 doesn't support inclusive rng = 0xFF. */
+    return off + buffered_uint8(brng_state, bcnt, buf);
+  } else {
+    if (use_masked) {
+      return off +
+             buffered_bounded_masked_uint8(brng_state, rng, mask, bcnt, buf);
+    } else {
+      return off + buffered_bounded_lemire_uint8(brng_state, rng, bcnt, buf);
+    }
+  }
+}
+
+static NPY_INLINE npy_bool buffered_bounded_bool(brng_t *brng_state,
+                                                 npy_bool off, npy_bool rng,
+                                                 npy_bool mask, int *bcnt,
+                                                 uint32_t *buf) {
+  if (rng == 0)
+    return off;
+  if (!(bcnt[0])) {
+    buf[0] = next_uint32(brng_state);
+    bcnt[0] = 31;
+  } else {
+    buf[0] >>= 1;
+    bcnt[0] -= 1;
+  }
+  return (buf[0] & 0x00000001UL) != 0;
+}
+
+npy_bool random_buffered_bounded_bool(brng_t *brng_state, npy_bool off,
+                                      npy_bool rng, npy_bool mask,
+                                      bool use_masked, int *bcnt,
+                                      uint32_t *buf) {
+  return buffered_bounded_bool(brng_state, off, rng, mask, bcnt, buf);
+}
+
+/*
+ * Fills an array with cnt random npy_uint64 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void random_bounded_uint64_fill(brng_t *brng_state, uint64_t off, uint64_t rng,
+                                npy_intp cnt, bool use_masked, uint64_t *out) {
+  npy_intp i;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+  } else if (rng < 0xFFFFFFFFUL) {
+    uint32_t buf = 0;
+    int bcnt = 0;
+
+    /* Call 32-bit generator if range in 32-bit. */
+    if (use_masked) {
+      /* Smallest bit mask >= max */
+      uint64_t mask = gen_mask(rng);
+
+      for (i = 0; i < cnt; i++) {
+        out[i] = off + buffered_bounded_masked_uint32(brng_state, rng, mask,
+                                                      &bcnt, &buf);
+      }
+    } else {
+      for (i = 0; i < cnt; i++) {
+        out[i] =
+            off + buffered_bounded_lemire_uint32(brng_state, rng, &bcnt, &buf);
+      }
+    }
+  } else if (rng == 0xFFFFFFFFFFFFFFFFULL) {
+    /* Lemire64 doesn't support rng = 0xFFFFFFFFFFFFFFFF. */
+    for (i = 0; i < cnt; i++) {
+      out[i] = off + next_uint64(brng_state);
+    }
+  } else {
+    if (use_masked) {
+      /* Smallest bit mask >= max */
+      uint64_t mask = gen_mask(rng);
+
+      for (i = 0; i < cnt; i++) {
+        out[i] = off + bounded_masked_uint64(brng_state, rng, mask);
+      }
+    } else {
+      for (i = 0; i < cnt; i++) {
+        out[i] = off + bounded_lemire_uint64(brng_state, rng);
+      }
+    }
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_uint32 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void random_bounded_uint32_fill(brng_t *brng_state, uint32_t off, uint32_t rng,
+                                npy_intp cnt, bool use_masked, uint32_t *out) {
+  npy_intp i;
+  uint32_t buf = 0;
+  int bcnt = 0;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+  } else if (rng == 0xFFFFFFFFUL) {
+    /* Lemire32 doesn't support rng = 0xFFFFFFFF. */
+    for (i = 0; i < cnt; i++) {
+      out[i] = off + next_uint32(brng_state);
+    }
+  } else {
+    if (use_masked) {
+      /* Smallest bit mask >= max */
+      uint32_t mask = (uint32_t)gen_mask(rng);
+
+      for (i = 0; i < cnt; i++) {
+        out[i] = off + buffered_bounded_masked_uint32(brng_state, rng, mask,
+                                                      &bcnt, &buf);
+      }
+    } else {
+      for (i = 0; i < cnt; i++) {
+        out[i] =
+            off + buffered_bounded_lemire_uint32(brng_state, rng, &bcnt, &buf);
+      }
+    }
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_uint16 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void random_bounded_uint16_fill(brng_t *brng_state, uint16_t off, uint16_t rng,
+                                npy_intp cnt, bool use_masked, uint16_t *out) {
+  npy_intp i;
+  uint32_t buf = 0;
+  int bcnt = 0;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+  } else if (rng == 0xFFFFUL) {
+    /* Lemire16 doesn't support rng = 0xFFFF. */
+    for (i = 0; i < cnt; i++) {
+      out[i] = off + buffered_uint16(brng_state, &bcnt, &buf);
+    }
+  } else {
+    if (use_masked) {
+      /* Smallest bit mask >= max */
+      uint16_t mask = (uint16_t)gen_mask(rng);
+
+      for (i = 0; i < cnt; i++) {
+        out[i] = off + buffered_bounded_masked_uint16(brng_state, rng, mask,
+                                                      &bcnt, &buf);
+      }
+    } else {
+      for (i = 0; i < cnt; i++) {
+        out[i] =
+            off + buffered_bounded_lemire_uint16(brng_state, rng, &bcnt, &buf);
+      }
+    }
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_uint8 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void random_bounded_uint8_fill(brng_t *brng_state, uint8_t off, uint8_t rng,
+                               npy_intp cnt, bool use_masked, uint8_t *out) {
+  npy_intp i;
+  uint32_t buf = 0;
+  int bcnt = 0;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+  } else if (rng == 0xFFUL) {
+    /* Lemire8 doesn't support rng = 0xFF. */
+    for (i = 0; i < cnt; i++) {
+      out[i] = off + buffered_uint8(brng_state, &bcnt, &buf);
+    }
+  } else {
+    if (use_masked) {
+      /* Smallest bit mask >= max */
+      uint8_t mask = (uint8_t)gen_mask(rng);
+
+      for (i = 0; i < cnt; i++) {
+        out[i] = off + buffered_bounded_masked_uint8(brng_state, rng, mask,
+                                                     &bcnt, &buf);
+      }
+    } else {
+      for (i = 0; i < cnt; i++) {
+        out[i] =
+            off + buffered_bounded_lemire_uint8(brng_state, rng, &bcnt, &buf);
+      }
+    }
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_bool between off and off + rng
+ * inclusive.
+ */
+void random_bounded_bool_fill(brng_t *brng_state, npy_bool off, npy_bool rng,
+                              npy_intp cnt, bool use_masked, npy_bool *out) {
+  npy_bool mask = 0;
+  npy_intp i;
+  uint32_t buf = 0;
+  int bcnt = 0;
+
+  for (i = 0; i < cnt; i++) {
+    out[i] = buffered_bounded_bool(brng_state, off, rng, mask, &bcnt, &buf);
+  }
+}
diff --git a/numpy/random/src/distributions/distributions.h b/numpy/random/src/distributions/distributions.h
new file mode 100644
index 000000000..7ca31a16c
--- /dev/null
+++ b/numpy/random/src/distributions/distributions.h
@@ -0,0 +1,220 @@
+#ifndef _RANDOMDGEN__DISTRIBUTIONS_H_
+#define _RANDOMDGEN__DISTRIBUTIONS_H_
+
+#pragma once
+#include <stddef.h>
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/stdint.h"
+typedef int bool;
+#define false 0
+#define true 1
+#else
+#include <stdbool.h>
+#include <stdint.h>
+#endif
+#else
+#include <stdbool.h>
+#include <stdint.h>
+#endif
+
+#include "Python.h"
+#include "numpy/npy_common.h"
+#include "numpy/npy_math.h"
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+
+static NPY_INLINE int64_t llabs(int64_t x) {
+  int64_t o;
+  if (x < 0) {
+    o = -x;
+  } else {
+    o = x;
+  }
+  return o;
+}
+#endif
+#endif
+
+#ifdef DLL_EXPORT
+#define DECLDIR __declspec(dllexport)
+#else
+#define DECLDIR extern
+#endif
+
+#ifndef MIN
+#define MIN(x, y) (((x) < (y)) ? x : y)
+#define MAX(x, y) (((x) > (y)) ? x : y)
+#endif
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338328
+#endif
+
+typedef struct s_binomial_t {
+  int has_binomial; /* !=0: following parameters initialized for binomial */
+  double psave;
+  int64_t nsave;
+  double r;
+  double q;
+  double fm;
+  int64_t m;
+  double p1;
+  double xm;
+  double xl;
+  double xr;
+  double c;
+  double laml;
+  double lamr;
+  double p2;
+  double p3;
+  double p4;
+} binomial_t;
+
+typedef struct brng {
+  void *state;
+  uint64_t (*next_uint64)(void *st);
+  uint32_t (*next_uint32)(void *st);
+  double (*next_double)(void *st);
+  uint64_t (*next_raw)(void *st);
+} brng_t;
+
+/* Inline generators for internal use */
+static NPY_INLINE uint32_t next_uint32(brng_t *brng_state) {
+  return brng_state->next_uint32(brng_state->state);
+}
+
+static NPY_INLINE uint64_t next_uint64(brng_t *brng_state) {
+  return brng_state->next_uint64(brng_state->state);
+}
+
+static NPY_INLINE float next_float(brng_t *brng_state) {
+  return (next_uint32(brng_state) >> 9) * (1.0f / 8388608.0f);
+}
+
+static NPY_INLINE double next_double(brng_t *brng_state) {
+  return brng_state->next_double(brng_state->state);
+}
+
+DECLDIR float random_float(brng_t *brng_state);
+DECLDIR double random_double(brng_t *brng_state);
+DECLDIR void random_double_fill(brng_t *brng_state, npy_intp cnt, double *out);
+
+DECLDIR int64_t random_positive_int64(brng_t *brng_state);
+DECLDIR int32_t random_positive_int32(brng_t *brng_state);
+DECLDIR int64_t random_positive_int(brng_t *brng_state);
+DECLDIR uint64_t random_uint(brng_t *brng_state);
+
+DECLDIR double random_standard_exponential(brng_t *brng_state);
+DECLDIR void random_standard_exponential_fill(brng_t *brng_state, npy_intp cnt,
+                                              double *out);
+DECLDIR float random_standard_exponential_f(brng_t *brng_state);
+DECLDIR double random_standard_exponential_zig(brng_t *brng_state);
+DECLDIR void random_standard_exponential_zig_fill(brng_t *brng_state,
+                                                  npy_intp cnt, double *out);
+DECLDIR float random_standard_exponential_zig_f(brng_t *brng_state);
+
+/*
+DECLDIR double random_gauss(brng_t *brng_state);
+DECLDIR float random_gauss_f(brng_t *brng_state);
+*/
+DECLDIR double random_gauss_zig(brng_t *brng_state);
+DECLDIR float random_gauss_zig_f(brng_t *brng_state);
+DECLDIR void random_gauss_zig_fill(brng_t *brng_state, npy_intp cnt,
+                                   double *out);
+
+/*
+DECLDIR double random_standard_gamma(brng_t *brng_state, double shape);
+DECLDIR float random_standard_gamma_f(brng_t *brng_state, float shape);
+*/
+DECLDIR double random_standard_gamma_zig(brng_t *brng_state, double shape);
+DECLDIR float random_standard_gamma_zig_f(brng_t *brng_state, float shape);
+
+/*
+DECLDIR double random_normal(brng_t *brng_state, double loc, double scale);
+*/
+DECLDIR double random_normal_zig(brng_t *brng_state, double loc, double scale);
+
+DECLDIR double random_gamma(brng_t *brng_state, double shape, double scale);
+DECLDIR float random_gamma_float(brng_t *brng_state, float shape, float scale);
+
+DECLDIR double random_exponential(brng_t *brng_state, double scale);
+DECLDIR double random_uniform(brng_t *brng_state, double lower, double range);
+DECLDIR double random_beta(brng_t *brng_state, double a, double b);
+DECLDIR double random_chisquare(brng_t *brng_state, double df);
+DECLDIR double random_f(brng_t *brng_state, double dfnum, double dfden);
+DECLDIR double random_standard_cauchy(brng_t *brng_state);
+DECLDIR double random_pareto(brng_t *brng_state, double a);
+DECLDIR double random_weibull(brng_t *brng_state, double a);
+DECLDIR double random_power(brng_t *brng_state, double a);
+DECLDIR double random_laplace(brng_t *brng_state, double loc, double scale);
+DECLDIR double random_gumbel(brng_t *brng_state, double loc, double scale);
+DECLDIR double random_logistic(brng_t *brng_state, double loc, double scale);
+DECLDIR double random_lognormal(brng_t *brng_state, double mean, double sigma);
+DECLDIR double random_rayleigh(brng_t *brng_state, double mode);
+DECLDIR double random_standard_t(brng_t *brng_state, double df);
+DECLDIR double random_noncentral_chisquare(brng_t *brng_state, double df,
+                                           double nonc);
+DECLDIR double random_noncentral_f(brng_t *brng_state, double dfnum,
+                                   double dfden, double nonc);
+DECLDIR double random_wald(brng_t *brng_state, double mean, double scale);
+DECLDIR double random_vonmises(brng_t *brng_state, double mu, double kappa);
+DECLDIR double random_triangular(brng_t *brng_state, double left, double mode,
+                                 double right);
+
+DECLDIR int64_t random_poisson(brng_t *brng_state, double lam);
+DECLDIR int64_t random_negative_binomial(brng_t *brng_state, double n,
+                                         double p);
+DECLDIR int64_t random_binomial(brng_t *brng_state, double p, int64_t n,
+                                binomial_t *binomial);
+DECLDIR int64_t random_logseries(brng_t *brng_state, double p);
+DECLDIR int64_t random_geometric_search(brng_t *brng_state, double p);
+DECLDIR int64_t random_geometric_inversion(brng_t *brng_state, double p);
+DECLDIR int64_t random_geometric(brng_t *brng_state, double p);
+DECLDIR int64_t random_zipf(brng_t *brng_state, double a);
+DECLDIR int64_t random_hypergeometric(brng_t *brng_state, int64_t good,
+                                      int64_t bad, int64_t sample);
+
+DECLDIR uint64_t random_interval(brng_t *brng_state, uint64_t max);
+
+/* Generate random uint64 numbers in closed interval [off, off + rng]. */
+DECLDIR uint64_t random_bounded_uint64(brng_t *brng_state, uint64_t off,
+                                       uint64_t rng, uint64_t mask,
+                                       bool use_masked);
+
+/* Generate random uint32 numbers in closed interval [off, off + rng]. */
+DECLDIR uint32_t random_buffered_bounded_uint32(brng_t *brng_state,
+                                                uint32_t off, uint32_t rng,
+                                                uint32_t mask, bool use_masked,
+                                                int *bcnt, uint32_t *buf);
+DECLDIR uint16_t random_buffered_bounded_uint16(brng_t *brng_state,
+                                                uint16_t off, uint16_t rng,
+                                                uint16_t mask, bool use_masked,
+                                                int *bcnt, uint32_t *buf);
+DECLDIR uint8_t random_buffered_bounded_uint8(brng_t *brng_state, uint8_t off,
+                                              uint8_t rng, uint8_t mask,
+                                              bool use_masked, int *bcnt,
+                                              uint32_t *buf);
+DECLDIR npy_bool random_buffered_bounded_bool(brng_t *brng_state, npy_bool off,
+                                              npy_bool rng, npy_bool mask,
+                                              bool use_masked, int *bcnt,
+                                              uint32_t *buf);
+
+DECLDIR void random_bounded_uint64_fill(brng_t *brng_state, uint64_t off,
+                                        uint64_t rng, npy_intp cnt,
+                                        bool use_masked, uint64_t *out);
+DECLDIR void random_bounded_uint32_fill(brng_t *brng_state, uint32_t off,
+                                        uint32_t rng, npy_intp cnt,
+                                        bool use_masked, uint32_t *out);
+DECLDIR void random_bounded_uint16_fill(brng_t *brng_state, uint16_t off,
+                                        uint16_t rng, npy_intp cnt,
+                                        bool use_masked, uint16_t *out);
+DECLDIR void random_bounded_uint8_fill(brng_t *brng_state, uint8_t off,
+                                       uint8_t rng, npy_intp cnt,
+                                       bool use_masked, uint8_t *out);
+DECLDIR void random_bounded_bool_fill(brng_t *brng_state, npy_bool off,
+                                      npy_bool rng, npy_intp cnt,
+                                      bool use_masked, npy_bool *out);
+
+#endif
diff --git a/numpy/random/src/distributions/ziggurat.h b/numpy/random/src/distributions/ziggurat.h
new file mode 100644
index 000000000..7808c0e68
--- /dev/null
+++ b/numpy/random/src/distributions/ziggurat.h
@@ -0,0 +1,276 @@
+/*
+ * Constants from Julia's Ziggurat implementation
+ */
+
+static const uint64_t ki[] = {
+    0x0007799ec012f7b2, 0x0000000000000000, 0x0006045f4c7de363,
+    0x0006d1aa7d5ec0a5, 0x000728fb3f60f777, 0x0007592af4e9fbc0,
+    0x000777a5c0bf655d, 0x00078ca3857d2256, 0x00079bf6b0ffe58b,
+    0x0007a7a34ab092ad, 0x0007b0d2f20dd1cb, 0x0007b83d3aa9cb52,
+    0x0007be597614224d, 0x0007c3788631abe9, 0x0007c7d32bc192ee,
+    0x0007cb9263a6e86d, 0x0007ced483edfa84, 0x0007d1b07ac0fd39,
+    0x0007d437ef2da5fc, 0x0007d678b069aa6e, 0x0007d87db38c5c87,
+    0x0007da4fc6a9ba62, 0x0007dbf611b37f3b, 0x0007dd7674d0f286,
+    0x0007ded5ce8205f6, 0x0007e018307fb62b, 0x0007e141081bd124,
+    0x0007e2533d712de8, 0x0007e3514bbd7718, 0x0007e43d54944b52,
+    0x0007e5192f25ef42, 0x0007e5e67481118d, 0x0007e6a6897c1ce2,
+    0x0007e75aa6c7f64c, 0x0007e803df8ee498, 0x0007e8a326eb6272,
+    0x0007e93954717a28, 0x0007e9c727f8648f, 0x0007ea4d4cc85a3c,
+    0x0007eacc5c4907a9, 0x0007eb44e0474cf6, 0x0007ebb754e47419,
+    0x0007ec242a3d8474, 0x0007ec8bc5d69645, 0x0007ecee83d3d6e9,
+    0x0007ed4cb8082f45, 0x0007eda6aee0170f, 0x0007edfcae2dfe68,
+    0x0007ee4ef5dccd3e, 0x0007ee9dc08c394e, 0x0007eee9441a17c7,
+    0x0007ef31b21b4fb1, 0x0007ef773846a8a7, 0x0007efba00d35a17,
+    0x0007effa32ccf69f, 0x0007f037f25e1278, 0x0007f0736112d12c,
+    0x0007f0ac9e145c25, 0x0007f0e3c65e1fcc, 0x0007f118f4ed8e54,
+    0x0007f14c42ed0dc8, 0x0007f17dc7daa0c3, 0x0007f1ad99aac6a5,
+    0x0007f1dbcce80015, 0x0007f20874cf56bf, 0x0007f233a36a3b9a,
+    0x0007f25d69a604ad, 0x0007f285d7694a92, 0x0007f2acfba75e3b,
+    0x0007f2d2e4720909, 0x0007f2f79f09c344, 0x0007f31b37ec883b,
+    0x0007f33dbae36abc, 0x0007f35f330f08d5, 0x0007f37faaf2fa79,
+    0x0007f39f2c805380, 0x0007f3bdc11f4f1c, 0x0007f3db71b83850,
+    0x0007f3f846bba121, 0x0007f4144829f846, 0x0007f42f7d9a8b9d,
+    0x0007f449ee420432, 0x0007f463a0f8675e, 0x0007f47c9c3ea77b,
+    0x0007f494e643cd8e, 0x0007f4ac84e9c475, 0x0007f4c37dc9cd50,
+    0x0007f4d9d638a432, 0x0007f4ef934a5b6a, 0x0007f504b9d5f33d,
+    0x0007f5194e78b352, 0x0007f52d55994a96, 0x0007f540d36aba0c,
+    0x0007f553cbef0e77, 0x0007f56642f9ec8f, 0x0007f5783c32f31e,
+    0x0007f589bb17f609, 0x0007f59ac2ff1525, 0x0007f5ab5718b15a,
+    0x0007f5bb7a71427c, 0x0007f5cb2ff31009, 0x0007f5da7a67cebe,
+    0x0007f5e95c7a24e7, 0x0007f5f7d8b7171e, 0x0007f605f18f5ef4,
+    0x0007f613a958ad0a, 0x0007f621024ed7e9, 0x0007f62dfe94f8cb,
+    0x0007f63aa036777a, 0x0007f646e928065a, 0x0007f652db488f88,
+    0x0007f65e786213ff, 0x0007f669c22a7d8a, 0x0007f674ba446459,
+    0x0007f67f623fc8db, 0x0007f689bb9ac294, 0x0007f693c7c22481,
+    0x0007f69d881217a6, 0x0007f6a6fdd6ac36, 0x0007f6b02a4c61ee,
+    0x0007f6b90ea0a7f4, 0x0007f6c1abf254c0, 0x0007f6ca03521664,
+    0x0007f6d215c2db82, 0x0007f6d9e43a3559, 0x0007f6e16fa0b329,
+    0x0007f6e8b8d23729, 0x0007f6efc09e4569, 0x0007f6f687c84cbf,
+    0x0007f6fd0f07ea09, 0x0007f703570925e2, 0x0007f709606cad03,
+    0x0007f70f2bc8036f, 0x0007f714b9a5b292, 0x0007f71a0a85725d,
+    0x0007f71f1edc4d9e, 0x0007f723f714c179, 0x0007f728938ed843,
+    0x0007f72cf4a03fa0, 0x0007f7311a945a16, 0x0007f73505ac4bf8,
+    0x0007f738b61f03bd, 0x0007f73c2c193dc0, 0x0007f73f67bd835c,
+    0x0007f74269242559, 0x0007f745305b31a1, 0x0007f747bd666428,
+    0x0007f74a103f12ed, 0x0007f74c28d414f5, 0x0007f74e0709a42d,
+    0x0007f74faab939f9, 0x0007f75113b16657, 0x0007f75241b5a155,
+    0x0007f753347e16b8, 0x0007f753ebb76b7c, 0x0007f75467027d05,
+    0x0007f754a5f4199d, 0x0007f754a814b207, 0x0007f7546ce003ae,
+    0x0007f753f3c4bb29, 0x0007f7533c240e92, 0x0007f75245514f41,
+    0x0007f7510e91726c, 0x0007f74f971a9012, 0x0007f74dde135797,
+    0x0007f74be2927971, 0x0007f749a39e051c, 0x0007f747202aba8a,
+    0x0007f744571b4e3c, 0x0007f741473f9efe, 0x0007f73def53dc43,
+    0x0007f73a4dff9bff, 0x0007f73661d4deaf, 0x0007f732294f003f,
+    0x0007f72da2d19444, 0x0007f728cca72bda, 0x0007f723a5000367,
+    0x0007f71e29f09627, 0x0007f7185970156b, 0x0007f7123156c102,
+    0x0007f70baf5c1e2c, 0x0007f704d1150a23, 0x0007f6fd93f1a4e5,
+    0x0007f6f5f53b10b6, 0x0007f6edf211023e, 0x0007f6e587671ce9,
+    0x0007f6dcb2021679, 0x0007f6d36e749c64, 0x0007f6c9b91bf4c6,
+    0x0007f6bf8e1c541b, 0x0007f6b4e95ce015, 0x0007f6a9c68356ff,
+    0x0007f69e20ef5211, 0x0007f691f3b517eb, 0x0007f6853997f321,
+    0x0007f677ed03ff19, 0x0007f66a08075bdc, 0x0007f65b844ab75a,
+    0x0007f64c5b091860, 0x0007f63c8506d4bc, 0x0007f62bfa8798fe,
+    0x0007f61ab34364b0, 0x0007f608a65a599a, 0x0007f5f5ca4737e8,
+    0x0007f5e214d05b48, 0x0007f5cd7af7066e, 0x0007f5b7f0e4c2a1,
+    0x0007f5a169d68fcf, 0x0007f589d80596a5, 0x0007f5712c8d0174,
+    0x0007f557574c912b, 0x0007f53c46c77193, 0x0007f51fe7feb9f2,
+    0x0007f5022646ecfb, 0x0007f4e2eb17ab1d, 0x0007f4c21dd4a3d1,
+    0x0007f49fa38ea394, 0x0007f47b5ebb62eb, 0x0007f4552ee27473,
+    0x0007f42cf03d58f5, 0x0007f4027b48549f, 0x0007f3d5a44119df,
+    0x0007f3a63a8fb552, 0x0007f37408155100, 0x0007f33ed05b55ec,
+    0x0007f3064f9c183e, 0x0007f2ca399c7ba1, 0x0007f28a384bb940,
+    0x0007f245ea1b7a2b, 0x0007f1fcdffe8f1b, 0x0007f1ae9af758cd,
+    0x0007f15a8917f27e, 0x0007f10001ccaaab, 0x0007f09e413c418a,
+    0x0007f034627733d7, 0x0007efc15815b8d5, 0x0007ef43e2bf7f55,
+    0x0007eeba84e31dfe, 0x0007ee237294df89, 0x0007ed7c7c170141,
+    0x0007ecc2f0d95d3a, 0x0007ebf377a46782, 0x0007eb09d6deb285,
+    0x0007ea00a4f17808, 0x0007e8d0d3da63d6, 0x0007e771023b0fcf,
+    0x0007e5d46c2f08d8, 0x0007e3e937669691, 0x0007e195978f1176,
+    0x0007deb2c0e05c1c, 0x0007db0362002a19, 0x0007d6202c151439,
+    0x0007cf4b8f00a2cb, 0x0007c4fd24520efd, 0x0007b362fbf81816,
+    0x00078d2d25998e24};
+
+static const double wi[] = {
+    1.7367254121602630e-15, 9.5586603514556339e-17, 1.2708704834810623e-16,
+    1.4909740962495474e-16, 1.6658733631586268e-16, 1.8136120810119029e-16,
+    1.9429720153135588e-16, 2.0589500628482093e-16, 2.1646860576895422e-16,
+    2.2622940392218116e-16, 2.3532718914045892e-16, 2.4387234557428771e-16,
+    2.5194879829274225e-16, 2.5962199772528103e-16, 2.6694407473648285e-16,
+    2.7395729685142446e-16, 2.8069646002484804e-16, 2.8719058904113930e-16,
+    2.9346417484728883e-16, 2.9953809336782113e-16, 3.0543030007192440e-16,
+    3.1115636338921572e-16, 3.1672988018581815e-16, 3.2216280350549905e-16,
+    3.2746570407939751e-16, 3.3264798116841710e-16, 3.3771803417353232e-16,
+    3.4268340353119356e-16, 3.4755088731729758e-16, 3.5232663846002031e-16,
+    3.5701624633953494e-16, 3.6162480571598339e-16, 3.6615697529653540e-16,
+    3.7061702777236077e-16, 3.7500889278747798e-16, 3.7933619401549554e-16,
+    3.8360228129677279e-16, 3.8781025861250247e-16, 3.9196300853257678e-16,
+    3.9606321366256378e-16, 4.0011337552546690e-16, 4.0411583124143332e-16,
+    4.0807276830960448e-16, 4.1198623774807442e-16, 4.1585816580828064e-16,
+    4.1969036444740733e-16, 4.2348454071520708e-16, 4.2724230518899761e-16,
+    4.3096517957162941e-16, 4.3465460355128760e-16, 4.3831194100854571e-16,
+    4.4193848564470665e-16, 4.4553546609579137e-16, 4.4910405058828750e-16,
+    4.5264535118571397e-16, 4.5616042766900381e-16, 4.5965029108849407e-16,
+    4.6311590702081647e-16, 4.6655819856008752e-16, 4.6997804906941950e-16,
+    4.7337630471583237e-16, 4.7675377680908526e-16, 4.8011124396270155e-16,
+    4.8344945409350080e-16, 4.8676912627422087e-16, 4.9007095245229938e-16,
+    4.9335559904654139e-16, 4.9662370843221783e-16, 4.9987590032409088e-16,
+    5.0311277306593187e-16, 5.0633490483427195e-16, 5.0954285476338923e-16,
+    5.1273716399787966e-16, 5.1591835667857364e-16, 5.1908694086703434e-16,
+    5.2224340941340417e-16, 5.2538824077194543e-16, 5.2852189976823820e-16,
+    5.3164483832166176e-16, 5.3475749612647295e-16, 5.3786030129452348e-16,
+    5.4095367096239933e-16, 5.4403801186554671e-16, 5.4711372088173611e-16,
+    5.5018118554603362e-16, 5.5324078453927836e-16, 5.5629288815190902e-16,
+    5.5933785872484621e-16, 5.6237605106900435e-16, 5.6540781286489604e-16,
+    5.6843348504368141e-16, 5.7145340215092040e-16, 5.7446789269419609e-16,
+    5.7747727947569648e-16, 5.8048187991076857e-16, 5.8348200633338921e-16,
+    5.8647796628943653e-16, 5.8947006281858718e-16, 5.9245859472561339e-16,
+    5.9544385684180598e-16, 5.9842614027720281e-16, 6.0140573266426640e-16,
+    6.0438291839361250e-16, 6.0735797884236057e-16, 6.1033119259564394e-16,
+    6.1330283566179110e-16, 6.1627318168165963e-16, 6.1924250213258470e-16,
+    6.2221106652737879e-16, 6.2517914260879998e-16, 6.2814699653988953e-16,
+    6.3111489309056042e-16, 6.3408309582080600e-16, 6.3705186726088149e-16,
+    6.4002146908880247e-16, 6.4299216230548961e-16, 6.4596420740788321e-16,
+    6.4893786456033965e-16, 6.5191339376461587e-16, 6.5489105502874154e-16,
+    6.5787110853507413e-16, 6.6085381480782587e-16, 6.6383943488035057e-16,
+    6.6682823046247459e-16, 6.6982046410815579e-16, 6.7281639938375311e-16,
+    6.7581630103719006e-16, 6.7882043516829803e-16, 6.8182906940062540e-16,
+    6.8484247305500383e-16, 6.8786091732516637e-16, 6.9088467545571690e-16,
+    6.9391402292275690e-16, 6.9694923761748294e-16, 6.9999060003307640e-16,
+    7.0303839345521508e-16, 7.0609290415654822e-16, 7.0915442159548734e-16,
+    7.1222323861967788e-16, 7.1529965167453030e-16, 7.1838396101720629e-16,
+    7.2147647093647067e-16, 7.2457748997883870e-16, 7.2768733118146927e-16,
+    7.3080631231227429e-16, 7.3393475611774048e-16, 7.3707299057898310e-16,
+    7.4022134917657997e-16, 7.4338017116476479e-16, 7.4654980185558890e-16,
+    7.4973059291369793e-16, 7.5292290266240584e-16, 7.5612709640179217e-16,
+    7.5934354673958895e-16, 7.6257263393567558e-16, 7.6581474626104873e-16,
+    7.6907028037219191e-16, 7.7233964170182985e-16, 7.7562324486711744e-16,
+    7.7892151409638524e-16, 7.8223488367564108e-16, 7.8556379841610841e-16,
+    7.8890871414417552e-16, 7.9227009821522709e-16, 7.9564843005293662e-16,
+    7.9904420171571300e-16, 8.0245791849212591e-16, 8.0589009952726568e-16,
+    8.0934127848215009e-16, 8.1281200422845008e-16, 8.1630284158098775e-16,
+    8.1981437207065329e-16, 8.2334719476060504e-16, 8.2690192710884700e-16,
+    8.3047920588053737e-16, 8.3407968811366288e-16, 8.3770405214202216e-16,
+    8.4135299867980282e-16, 8.4502725197240968e-16, 8.4872756101861549e-16,
+    8.5245470086955962e-16, 8.5620947401062333e-16, 8.5999271183276646e-16,
+    8.6380527620052589e-16, 8.6764806112455816e-16, 8.7152199454736980e-16,
+    8.7542804025171749e-16, 8.7936719990210427e-16, 8.8334051523084080e-16,
+    8.8734907038131345e-16, 8.9139399442240861e-16, 8.9547646404950677e-16,
+    8.9959770648910994e-16, 9.0375900262601175e-16, 9.0796169037400680e-16,
+    9.1220716831348461e-16, 9.1649689962191353e-16, 9.2083241632623076e-16,
+    9.2521532390956933e-16, 9.2964730630864167e-16, 9.3413013134252651e-16,
+    9.3866565661866598e-16, 9.4325583596767065e-16, 9.4790272646517382e-16,
+    9.5260849610662787e-16, 9.5737543220974496e-16, 9.6220595062948384e-16,
+    9.6710260588230542e-16, 9.7206810229016259e-16, 9.7710530627072088e-16,
+    9.8221725991905411e-16, 9.8740719604806711e-16, 9.9267855488079765e-16,
+    9.9803500261836449e-16, 1.0034804521436181e-15, 1.0090190861637457e-15,
+    1.0146553831467086e-15, 1.0203941464683124e-15, 1.0262405372613567e-15,
+    1.0322001115486456e-15, 1.0382788623515399e-15, 1.0444832676000471e-15,
+    1.0508203448355195e-15, 1.0572977139009890e-15, 1.0639236690676801e-15,
+    1.0707072623632994e-15, 1.0776584002668106e-15, 1.0847879564403425e-15,
+    1.0921079038149563e-15, 1.0996314701785628e-15, 1.1073733224935752e-15,
+    1.1153497865853155e-15, 1.1235791107110833e-15, 1.1320817840164846e-15,
+    1.1408809242582780e-15, 1.1500027537839792e-15, 1.1594771891449189e-15,
+    1.1693385786910960e-15, 1.1796266352955801e-15, 1.1903876299282890e-15,
+    1.2016759392543819e-15, 1.2135560818666897e-15, 1.2261054417450561e-15,
+    1.2394179789163251e-15, 1.2536093926602567e-15, 1.2688244814255010e-15,
+    1.2852479319096109e-15, 1.3031206634689985e-15, 1.3227655770195326e-15,
+    1.3446300925011171e-15, 1.3693606835128518e-15, 1.3979436672775240e-15,
+    1.4319989869661328e-15, 1.4744848603597596e-15, 1.5317872741611144e-15,
+    1.6227698675312968e-15};
+
+static const double fi[] = {
+    1.0000000000000000e+00, 9.7710170126767082e-01, 9.5987909180010600e-01,
+    9.4519895344229909e-01, 9.3206007595922991e-01, 9.1999150503934646e-01,
+    9.0872644005213032e-01, 8.9809592189834297e-01, 8.8798466075583282e-01,
+    8.7830965580891684e-01, 8.6900868803685649e-01, 8.6003362119633109e-01,
+    8.5134625845867751e-01, 8.4291565311220373e-01, 8.3471629298688299e-01,
+    8.2672683394622093e-01, 8.1892919160370192e-01, 8.1130787431265572e-01,
+    8.0384948317096383e-01, 7.9654233042295841e-01, 7.8937614356602404e-01,
+    7.8234183265480195e-01, 7.7543130498118662e-01, 7.6863731579848571e-01,
+    7.6195334683679483e-01, 7.5537350650709567e-01, 7.4889244721915638e-01,
+    7.4250529634015061e-01, 7.3620759812686210e-01, 7.2999526456147568e-01,
+    7.2386453346862967e-01, 7.1781193263072152e-01, 7.1183424887824798e-01,
+    7.0592850133275376e-01, 7.0009191813651117e-01, 6.9432191612611627e-01,
+    6.8861608300467136e-01, 6.8297216164499430e-01, 6.7738803621877308e-01,
+    6.7186171989708166e-01, 6.6639134390874977e-01, 6.6097514777666277e-01,
+    6.5561147057969693e-01, 6.5029874311081637e-01, 6.4503548082082196e-01,
+    6.3982027745305614e-01, 6.3465179928762327e-01, 6.2952877992483625e-01,
+    6.2445001554702606e-01, 6.1941436060583399e-01, 6.1442072388891344e-01,
+    6.0946806492577310e-01, 6.0455539069746733e-01, 5.9968175261912482e-01,
+    5.9484624376798689e-01, 5.9004799633282545e-01, 5.8528617926337090e-01,
+    5.8055999610079034e-01, 5.7586868297235316e-01, 5.7121150673525267e-01,
+    5.6658776325616389e-01, 5.6199677581452390e-01, 5.5743789361876550e-01,
+    5.5291049042583185e-01, 5.4841396325526537e-01, 5.4394773119002582e-01,
+    5.3951123425695158e-01, 5.3510393238045717e-01, 5.3072530440366150e-01,
+    5.2637484717168403e-01, 5.2205207467232140e-01, 5.1775651722975591e-01,
+    5.1348772074732651e-01, 5.0924524599574761e-01, 5.0502866794346790e-01,
+    5.0083757512614835e-01, 4.9667156905248933e-01, 4.9253026364386815e-01,
+    4.8841328470545758e-01, 4.8432026942668288e-01, 4.8025086590904642e-01,
+    4.7620473271950547e-01, 4.7218153846772976e-01, 4.6818096140569321e-01,
+    4.6420268904817391e-01, 4.6024641781284248e-01, 4.5631185267871610e-01,
+    4.5239870686184824e-01, 4.4850670150720273e-01, 4.4463556539573912e-01,
+    4.4078503466580377e-01, 4.3695485254798533e-01, 4.3314476911265209e-01,
+    4.2935454102944126e-01, 4.2558393133802180e-01, 4.2183270922949573e-01,
+    4.1810064983784795e-01, 4.1438753404089090e-01, 4.1069314827018799e-01,
+    4.0701728432947315e-01, 4.0335973922111429e-01, 3.9972031498019700e-01,
+    3.9609881851583223e-01, 3.9249506145931540e-01, 3.8890886001878855e-01,
+    3.8534003484007706e-01, 3.8178841087339344e-01, 3.7825381724561896e-01,
+    3.7473608713789086e-01, 3.7123505766823922e-01, 3.6775056977903225e-01,
+    3.6428246812900372e-01, 3.6083060098964775e-01, 3.5739482014578022e-01,
+    3.5397498080007656e-01, 3.5057094148140588e-01, 3.4718256395679348e-01,
+    3.4380971314685055e-01, 3.4045225704452164e-01, 3.3711006663700588e-01,
+    3.3378301583071823e-01, 3.3047098137916342e-01, 3.2717384281360129e-01,
+    3.2389148237639104e-01, 3.2062378495690530e-01, 3.1737063802991350e-01,
+    3.1413193159633707e-01, 3.1090755812628634e-01, 3.0769741250429189e-01,
+    3.0450139197664983e-01, 3.0131939610080288e-01, 2.9815132669668531e-01,
+    2.9499708779996164e-01, 2.9185658561709499e-01, 2.8872972848218270e-01,
+    2.8561642681550159e-01, 2.8251659308370741e-01, 2.7943014176163772e-01,
+    2.7635698929566810e-01, 2.7329705406857691e-01, 2.7025025636587519e-01,
+    2.6721651834356114e-01, 2.6419576399726080e-01, 2.6118791913272082e-01,
+    2.5819291133761890e-01, 2.5521066995466168e-01, 2.5224112605594190e-01,
+    2.4928421241852824e-01, 2.4633986350126363e-01, 2.4340801542275012e-01,
+    2.4048860594050039e-01, 2.3758157443123795e-01, 2.3468686187232990e-01,
+    2.3180441082433859e-01, 2.2893416541468023e-01, 2.2607607132238020e-01,
+    2.2323007576391746e-01, 2.2039612748015194e-01, 2.1757417672433113e-01,
+    2.1476417525117358e-01, 2.1196607630703015e-01, 2.0917983462112499e-01,
+    2.0640540639788071e-01, 2.0364274931033485e-01, 2.0089182249465656e-01,
+    1.9815258654577511e-01, 1.9542500351413428e-01, 1.9270903690358912e-01,
+    1.9000465167046496e-01, 1.8731181422380025e-01, 1.8463049242679927e-01,
+    1.8196065559952254e-01, 1.7930227452284767e-01, 1.7665532144373500e-01,
+    1.7401977008183875e-01, 1.7139559563750595e-01, 1.6878277480121151e-01,
+    1.6618128576448205e-01, 1.6359110823236570e-01, 1.6101222343751107e-01,
+    1.5844461415592431e-01, 1.5588826472447920e-01, 1.5334316106026283e-01,
+    1.5080929068184568e-01, 1.4828664273257453e-01, 1.4577520800599403e-01,
+    1.4327497897351341e-01, 1.4078594981444470e-01, 1.3830811644855071e-01,
+    1.3584147657125373e-01, 1.3338602969166913e-01, 1.3094177717364430e-01,
+    1.2850872227999952e-01, 1.2608687022018586e-01, 1.2367622820159654e-01,
+    1.2127680548479021e-01, 1.1888861344290998e-01, 1.1651166562561080e-01,
+    1.1414597782783835e-01, 1.1179156816383801e-01, 1.0944845714681163e-01,
+    1.0711666777468364e-01, 1.0479622562248690e-01, 1.0248715894193508e-01,
+    1.0018949876880981e-01, 9.7903279038862284e-02, 9.5628536713008819e-02,
+    9.3365311912690860e-02, 9.1113648066373634e-02, 8.8873592068275789e-02,
+    8.6645194450557961e-02, 8.4428509570353374e-02, 8.2223595813202863e-02,
+    8.0030515814663056e-02, 7.7849336702096039e-02, 7.5680130358927067e-02,
+    7.3522973713981268e-02, 7.1377949058890375e-02, 6.9245144397006769e-02,
+    6.7124653827788497e-02, 6.5016577971242842e-02, 6.2921024437758113e-02,
+    6.0838108349539864e-02, 5.8767952920933758e-02, 5.6710690106202902e-02,
+    5.4666461324888914e-02, 5.2635418276792176e-02, 5.0617723860947761e-02,
+    4.8613553215868521e-02, 4.6623094901930368e-02, 4.4646552251294443e-02,
+    4.2684144916474431e-02, 4.0736110655940933e-02, 3.8802707404526113e-02,
+    3.6884215688567284e-02, 3.4980941461716084e-02, 3.3093219458578522e-02,
+    3.1221417191920245e-02, 2.9365939758133314e-02, 2.7527235669603082e-02,
+    2.5705804008548896e-02, 2.3902203305795882e-02, 2.2117062707308864e-02,
+    2.0351096230044517e-02, 1.8605121275724643e-02, 1.6880083152543166e-02,
+    1.5177088307935325e-02, 1.3497450601739880e-02, 1.1842757857907888e-02,
+    1.0214971439701471e-02, 8.6165827693987316e-03, 7.0508754713732268e-03,
+    5.5224032992509968e-03, 4.0379725933630305e-03, 2.6090727461021627e-03,
+    1.2602859304985975e-03};
+
+static const double ziggurat_nor_r = 3.6541528853610087963519472518;
+static const double ziggurat_nor_inv_r =
+    0.27366123732975827203338247596; // 1.0 / ziggurat_nor_r;
+static const double ziggurat_exp_r = 7.6971174701310497140446280481;
+
+static const float ziggurat_nor_r_f = 3.6541528853610087963519472518f;
+static const float ziggurat_nor_inv_r_f = 0.27366123732975827203338247596f;
+static const float ziggurat_exp_r_f = 7.6971174701310497140446280481f;
diff --git a/numpy/random/src/distributions/ziggurat_constants.h b/numpy/random/src/distributions/ziggurat_constants.h
new file mode 100644
index 000000000..17eccec0f
--- /dev/null
+++ b/numpy/random/src/distributions/ziggurat_constants.h
@@ -0,0 +1,1196 @@
+static const uint64_t ki_double[] = {
+    0x000EF33D8025EF6AULL, 0x0000000000000000ULL, 0x000C08BE98FBC6A8ULL,
+    0x000DA354FABD8142ULL, 0x000E51F67EC1EEEAULL, 0x000EB255E9D3F77EULL,
+    0x000EEF4B817ECAB9ULL, 0x000F19470AFA44AAULL, 0x000F37ED61FFCB18ULL,
+    0x000F4F469561255CULL, 0x000F61A5E41BA396ULL, 0x000F707A755396A4ULL,
+    0x000F7CB2EC28449AULL, 0x000F86F10C6357D3ULL, 0x000F8FA6578325DEULL,
+    0x000F9724C74DD0DAULL, 0x000F9DA907DBF509ULL, 0x000FA360F581FA74ULL,
+    0x000FA86FDE5B4BF8ULL, 0x000FACF160D354DCULL, 0x000FB0FB6718B90FULL,
+    0x000FB49F8D5374C6ULL, 0x000FB7EC2366FE77ULL, 0x000FBAECE9A1E50EULL,
+    0x000FBDAB9D040BEDULL, 0x000FC03060FF6C57ULL, 0x000FC2821037A248ULL,
+    0x000FC4A67AE25BD1ULL, 0x000FC6A2977AEE31ULL, 0x000FC87AA92896A4ULL,
+    0x000FCA325E4BDE85ULL, 0x000FCBCCE902231AULL, 0x000FCD4D12F839C4ULL,
+    0x000FCEB54D8FEC99ULL, 0x000FD007BF1DC930ULL, 0x000FD1464DD6C4E6ULL,
+    0x000FD272A8E2F450ULL, 0x000FD38E4FF0C91EULL, 0x000FD49A9990B478ULL,
+    0x000FD598B8920F53ULL, 0x000FD689C08E99ECULL, 0x000FD76EA9C8E832ULL,
+    0x000FD848547B08E8ULL, 0x000FD9178BAD2C8CULL, 0x000FD9DD07A7ADD2ULL,
+    0x000FDA9970105E8CULL, 0x000FDB4D5DC02E20ULL, 0x000FDBF95C5BFCD0ULL,
+    0x000FDC9DEBB99A7DULL, 0x000FDD3B8118729DULL, 0x000FDDD288342F90ULL,
+    0x000FDE6364369F64ULL, 0x000FDEEE708D514EULL, 0x000FDF7401A6B42EULL,
+    0x000FDFF46599ED40ULL, 0x000FE06FE4BC24F2ULL, 0x000FE0E6C225A258ULL,
+    0x000FE1593C28B84CULL, 0x000FE1C78CBC3F99ULL, 0x000FE231E9DB1CAAULL,
+    0x000FE29885DA1B91ULL, 0x000FE2FB8FB54186ULL, 0x000FE35B33558D4AULL,
+    0x000FE3B799D0002AULL, 0x000FE410E99EAD7FULL, 0x000FE46746D47734ULL,
+    0x000FE4BAD34C095CULL, 0x000FE50BAED29524ULL, 0x000FE559F74EBC78ULL,
+    0x000FE5A5C8E41212ULL, 0x000FE5EF3E138689ULL, 0x000FE6366FD91078ULL,
+    0x000FE67B75C6D578ULL, 0x000FE6BE661E11AAULL, 0x000FE6FF55E5F4F2ULL,
+    0x000FE73E5900A702ULL, 0x000FE77B823E9E39ULL, 0x000FE7B6E37070A2ULL,
+    0x000FE7F08D774243ULL, 0x000FE8289053F08CULL, 0x000FE85EFB35173AULL,
+    0x000FE893DC840864ULL, 0x000FE8C741F0CEBCULL, 0x000FE8F9387D4EF6ULL,
+    0x000FE929CC879B1DULL, 0x000FE95909D388EAULL, 0x000FE986FB939AA2ULL,
+    0x000FE9B3AC714866ULL, 0x000FE9DF2694B6D5ULL, 0x000FEA0973ABE67CULL,
+    0x000FEA329CF166A4ULL, 0x000FEA5AAB32952CULL, 0x000FEA81A6D5741AULL,
+    0x000FEAA797DE1CF0ULL, 0x000FEACC85F3D920ULL, 0x000FEAF07865E63CULL,
+    0x000FEB13762FEC13ULL, 0x000FEB3585FE2A4AULL, 0x000FEB56AE3162B4ULL,
+    0x000FEB76F4E284FAULL, 0x000FEB965FE62014ULL, 0x000FEBB4F4CF9D7CULL,
+    0x000FEBD2B8F449D0ULL, 0x000FEBEFB16E2E3EULL, 0x000FEC0BE31EBDE8ULL,
+    0x000FEC2752B15A15ULL, 0x000FEC42049DAFD3ULL, 0x000FEC5BFD29F196ULL,
+    0x000FEC75406CEEF4ULL, 0x000FEC8DD2500CB4ULL, 0x000FECA5B6911F12ULL,
+    0x000FECBCF0C427FEULL, 0x000FECD38454FB15ULL, 0x000FECE97488C8B3ULL,
+    0x000FECFEC47F91B7ULL, 0x000FED1377358528ULL, 0x000FED278F844903ULL,
+    0x000FED3B10242F4CULL, 0x000FED4DFBAD586EULL, 0x000FED605498C3DDULL,
+    0x000FED721D414FE8ULL, 0x000FED8357E4A982ULL, 0x000FED9406A42CC8ULL,
+    0x000FEDA42B85B704ULL, 0x000FEDB3C8746AB4ULL, 0x000FEDC2DF416652ULL,
+    0x000FEDD171A46E52ULL, 0x000FEDDF813C8AD3ULL, 0x000FEDED0F909980ULL,
+    0x000FEDFA1E0FD414ULL, 0x000FEE06AE124BC4ULL, 0x000FEE12C0D95A06ULL,
+    0x000FEE1E579006E0ULL, 0x000FEE29734B6524ULL, 0x000FEE34150AE4BCULL,
+    0x000FEE3E3DB89B3CULL, 0x000FEE47EE2982F4ULL, 0x000FEE51271DB086ULL,
+    0x000FEE59E9407F41ULL, 0x000FEE623528B42EULL, 0x000FEE6A0B5897F1ULL,
+    0x000FEE716C3E077AULL, 0x000FEE7858327B82ULL, 0x000FEE7ECF7B06BAULL,
+    0x000FEE84D2484AB2ULL, 0x000FEE8A60B66343ULL, 0x000FEE8F7ACCC851ULL,
+    0x000FEE94207E25DAULL, 0x000FEE9851A829EAULL, 0x000FEE9C0E13485CULL,
+    0x000FEE9F557273F4ULL, 0x000FEEA22762CCAEULL, 0x000FEEA4836B42ACULL,
+    0x000FEEA668FC2D71ULL, 0x000FEEA7D76ED6FAULL, 0x000FEEA8CE04FA0AULL,
+    0x000FEEA94BE8333BULL, 0x000FEEA950296410ULL, 0x000FEEA8D9C0075EULL,
+    0x000FEEA7E7897654ULL, 0x000FEEA678481D24ULL, 0x000FEEA48AA29E83ULL,
+    0x000FEEA21D22E4DAULL, 0x000FEE9F2E352024ULL, 0x000FEE9BBC26AF2EULL,
+    0x000FEE97C524F2E4ULL, 0x000FEE93473C0A3AULL, 0x000FEE8E40557516ULL,
+    0x000FEE88AE369C7AULL, 0x000FEE828E7F3DFDULL, 0x000FEE7BDEA7B888ULL,
+    0x000FEE749BFF37FFULL, 0x000FEE6CC3A9BD5EULL, 0x000FEE64529E007EULL,
+    0x000FEE5B45A32888ULL, 0x000FEE51994E57B6ULL, 0x000FEE474A0006CFULL,
+    0x000FEE3C53E12C50ULL, 0x000FEE30B2E02AD8ULL, 0x000FEE2462AD8205ULL,
+    0x000FEE175EB83C5AULL, 0x000FEE09A22A1447ULL, 0x000FEDFB27E349CCULL,
+    0x000FEDEBEA76216CULL, 0x000FEDDBE422047EULL, 0x000FEDCB0ECE39D3ULL,
+    0x000FEDB964042CF4ULL, 0x000FEDA6DCE938C9ULL, 0x000FED937237E98DULL,
+    0x000FED7F1C38A836ULL, 0x000FED69D2B9C02BULL, 0x000FED538D06AE00ULL,
+    0x000FED3C41DEA422ULL, 0x000FED23E76A2FD8ULL, 0x000FED0A732FE644ULL,
+    0x000FECEFDA07FE34ULL, 0x000FECD4100EB7B8ULL, 0x000FECB708956EB4ULL,
+    0x000FEC98B61230C1ULL, 0x000FEC790A0DA978ULL, 0x000FEC57F50F31FEULL,
+    0x000FEC356686C962ULL, 0x000FEC114CB4B335ULL, 0x000FEBEB948E6FD0ULL,
+    0x000FEBC429A0B692ULL, 0x000FEB9AF5EE0CDCULL, 0x000FEB6FE1C98542ULL,
+    0x000FEB42D3AD1F9EULL, 0x000FEB13B00B2D4BULL, 0x000FEAE2591A02E9ULL,
+    0x000FEAAEAE992257ULL, 0x000FEA788D8EE326ULL, 0x000FEA3FCFFD73E5ULL,
+    0x000FEA044C8DD9F6ULL, 0x000FE9C5D62F563BULL, 0x000FE9843BA947A4ULL,
+    0x000FE93F471D4728ULL, 0x000FE8F6BD76C5D6ULL, 0x000FE8AA5DC4E8E6ULL,
+    0x000FE859E07AB1EAULL, 0x000FE804F690A940ULL, 0x000FE7AB488233C0ULL,
+    0x000FE74C751F6AA5ULL, 0x000FE6E8102AA202ULL, 0x000FE67DA0B6ABD8ULL,
+    0x000FE60C9F38307EULL, 0x000FE5947338F742ULL, 0x000FE51470977280ULL,
+    0x000FE48BD436F458ULL, 0x000FE3F9BFFD1E37ULL, 0x000FE35D35EEB19CULL,
+    0x000FE2B5122FE4FEULL, 0x000FE20003995557ULL, 0x000FE13C82788314ULL,
+    0x000FE068C4EE67B0ULL, 0x000FDF82B02B71AAULL, 0x000FDE87C57EFEAAULL,
+    0x000FDD7509C63BFDULL, 0x000FDC46E529BF13ULL, 0x000FDAF8F82E0282ULL,
+    0x000FD985E1B2BA75ULL, 0x000FD7E6EF48CF04ULL, 0x000FD613ADBD650BULL,
+    0x000FD40149E2F012ULL, 0x000FD1A1A7B4C7ACULL, 0x000FCEE204761F9EULL,
+    0x000FCBA8D85E11B2ULL, 0x000FC7D26ECD2D22ULL, 0x000FC32B2F1E22EDULL,
+    0x000FBD6581C0B83AULL, 0x000FB606C4005434ULL, 0x000FAC40582A2874ULL,
+    0x000F9E971E014598ULL, 0x000F89FA48A41DFCULL, 0x000F66C5F7F0302CULL,
+    0x000F1A5A4B331C4AULL};
+
+static const double wi_double[] = {
+    8.68362706080130616677e-16, 4.77933017572773682428e-17,
+    6.35435241740526230246e-17, 7.45487048124769627714e-17,
+    8.32936681579309972857e-17, 9.06806040505948228243e-17,
+    9.71486007656776183958e-17, 1.02947503142410192108e-16,
+    1.08234302884476839838e-16, 1.13114701961090307945e-16,
+    1.17663594570229211411e-16, 1.21936172787143633280e-16,
+    1.25974399146370927864e-16, 1.29810998862640315416e-16,
+    1.33472037368241227547e-16, 1.36978648425712032797e-16,
+    1.40348230012423820659e-16, 1.43595294520569430270e-16,
+    1.46732087423644219083e-16, 1.49769046683910367425e-16,
+    1.52715150035961979750e-16, 1.55578181694607639484e-16,
+    1.58364940092908853989e-16, 1.61081401752749279325e-16,
+    1.63732852039698532012e-16, 1.66323990584208352778e-16,
+    1.68859017086765964015e-16, 1.71341701765596607184e-16,
+    1.73775443658648593310e-16, 1.76163319230009959832e-16,
+    1.78508123169767272927e-16, 1.80812402857991522674e-16,
+    1.83078487648267501776e-16, 1.85308513886180189386e-16,
+    1.87504446393738816849e-16, 1.89668097007747596212e-16,
+    1.91801140648386198029e-16, 1.93905129306251037069e-16,
+    1.95981504266288244037e-16, 1.98031606831281739736e-16,
+    2.00056687762733300198e-16, 2.02057915620716538808e-16,
+    2.04036384154802118313e-16, 2.05993118874037063144e-16,
+    2.07929082904140197311e-16, 2.09845182223703516690e-16,
+    2.11742270357603418769e-16, 2.13621152594498681022e-16,
+    2.15482589785814580926e-16, 2.17327301775643674990e-16,
+    2.19155970504272708519e-16, 2.20969242822353175995e-16,
+    2.22767733047895534948e-16, 2.24552025294143552381e-16,
+    2.26322675592856786566e-16, 2.28080213834501706782e-16,
+    2.29825145544246839061e-16, 2.31557953510408037008e-16,
+    2.33279099280043561128e-16, 2.34989024534709550938e-16,
+    2.36688152357916037468e-16, 2.38376888404542434981e-16,
+    2.40055621981350627349e-16, 2.41724727046750252175e-16,
+    2.43384563137110286400e-16, 2.45035476226149539878e-16,
+    2.46677799523270498158e-16, 2.48311854216108767769e-16,
+    2.49937950162045242375e-16, 2.51556386532965786439e-16,
+    2.53167452417135826983e-16, 2.54771427381694417303e-16,
+    2.56368581998939683749e-16, 2.57959178339286723500e-16,
+    2.59543470433517070146e-16, 2.61121704706701939097e-16,
+    2.62694120385972564623e-16, 2.64260949884118951286e-16,
+    2.65822419160830680292e-16, 2.67378748063236329361e-16,
+    2.68930150647261591777e-16, 2.70476835481199518794e-16,
+    2.72019005932773206655e-16, 2.73556860440867908686e-16,
+    2.75090592773016664571e-16, 2.76620392269639032183e-16,
+    2.78146444075954410103e-16, 2.79668929362423005309e-16,
+    2.81188025534502074329e-16, 2.82703906432447923059e-16,
+    2.84216742521840606520e-16, 2.85726701075460149289e-16,
+    2.87233946347097994381e-16, 2.88738639737848191815e-16,
+    2.90240939955384233230e-16, 2.91741003166694553259e-16,
+    2.93238983144718163965e-16, 2.94735031409293489611e-16,
+    2.96229297362806647792e-16, 2.97721928420902891115e-16,
+    2.99213070138601307081e-16, 3.00702866332133102993e-16,
+    3.02191459196806151971e-16, 3.03678989421180184427e-16,
+    3.05165596297821922381e-16, 3.06651417830895451744e-16,
+    3.08136590840829717032e-16, 3.09621251066292253306e-16,
+    3.11105533263689296831e-16, 3.12589571304399892784e-16,
+    3.14073498269944617203e-16, 3.15557446545280064031e-16,
+    3.17041547910402852545e-16, 3.18525933630440648871e-16,
+    3.20010734544401137886e-16, 3.21496081152744704901e-16,
+    3.22982103703941557538e-16, 3.24468932280169778077e-16,
+    3.25956696882307838340e-16, 3.27445527514370671802e-16,
+    3.28935554267536967851e-16, 3.30426907403912838589e-16,
+    3.31919717440175233652e-16, 3.33414115231237245918e-16,
+    3.34910232054077845412e-16, 3.36408199691876507948e-16,
+    3.37908150518594979994e-16, 3.39410217584148914282e-16,
+    3.40914534700312603713e-16, 3.42421236527501816058e-16,
+    3.43930458662583133920e-16, 3.45442337727858401604e-16,
+    3.46957011461378353333e-16, 3.48474618808741370700e-16,
+    3.49995300016538099813e-16, 3.51519196727607440975e-16,
+    3.53046452078274009054e-16, 3.54577210797743572160e-16,
+    3.56111619309838843415e-16, 3.57649825837265051035e-16,
+    3.59191980508602994994e-16, 3.60738235468235137839e-16,
+    3.62288744989419151904e-16, 3.63843665590734438546e-16,
+    3.65403156156136995766e-16, 3.66967378058870090021e-16,
+    3.68536495289491401456e-16, 3.70110674588289834952e-16,
+    3.71690085582382297792e-16, 3.73274900927794352614e-16,
+    3.74865296456848868882e-16, 3.76461451331202869131e-16,
+    3.78063548200896037651e-16, 3.79671773369794425924e-16,
+    3.81286316967837738238e-16, 3.82907373130524317507e-16,
+    3.84535140186095955858e-16, 3.86169820850914927119e-16,
+    3.87811622433558721164e-16, 3.89460757048192620674e-16,
+    3.91117441837820542060e-16, 3.92781899208054153270e-16,
+    3.94454357072087711446e-16, 3.96135049107613542983e-16,
+    3.97824215026468259474e-16, 3.99522100857856502444e-16,
+    4.01228959246062907451e-16, 4.02945049763632792393e-16,
+    4.04670639241074995115e-16, 4.06406002114225038723e-16,
+    4.08151420790493873480e-16, 4.09907186035326643447e-16,
+    4.11673597380302570170e-16, 4.13450963554423599878e-16,
+    4.15239602940268833891e-16, 4.17039844056831587498e-16,
+    4.18852026071011229572e-16, 4.20676499339901510978e-16,
+    4.22513625986204937320e-16, 4.24363780509307796137e-16,
+    4.26227350434779809917e-16, 4.28104737005311666397e-16,
+    4.29996355916383230161e-16, 4.31902638100262944617e-16,
+    4.33824030562279080411e-16, 4.35760997273684900553e-16,
+    4.37714020125858747008e-16, 4.39683599951052137423e-16,
+    4.41670257615420348435e-16, 4.43674535190656726604e-16,
+    4.45696997211204306674e-16, 4.47738232024753387312e-16,
+    4.49798853244554968009e-16, 4.51879501313005876278e-16,
+    4.53980845187003400947e-16, 4.56103584156742206384e-16,
+    4.58248449810956667052e-16, 4.60416208163115281428e-16,
+    4.62607661954784567754e-16, 4.64823653154320737780e-16,
+    4.67065065671263059081e-16, 4.69332828309332890697e-16,
+    4.71627917983835129766e-16, 4.73951363232586715165e-16,
+    4.76304248053313737663e-16, 4.78687716104872284247e-16,
+    4.81102975314741720538e-16, 4.83551302941152515162e-16,
+    4.86034051145081195402e-16, 4.88552653135360343280e-16,
+    4.91108629959526955862e-16, 4.93703598024033454728e-16,
+    4.96339277440398725619e-16, 4.99017501309182245754e-16,
+    5.01740226071808946011e-16, 5.04509543081872748637e-16,
+    5.07327691573354207058e-16, 5.10197073234156184149e-16,
+    5.13120268630678373200e-16, 5.16100055774322824569e-16,
+    5.19139431175769859873e-16, 5.22241633800023428760e-16,
+    5.25410172417759732697e-16, 5.28648856950494511482e-16,
+    5.31961834533840037535e-16, 5.35353631181649688145e-16,
+    5.38829200133405320160e-16, 5.42393978220171234073e-16,
+    5.46053951907478041166e-16, 5.49815735089281410703e-16,
+    5.53686661246787600374e-16, 5.57674893292657647836e-16,
+    5.61789555355541665830e-16, 5.66040892008242216739e-16,
+    5.70440462129138908417e-16, 5.75001376891989523684e-16,
+    5.79738594572459365014e-16, 5.84669289345547900201e-16,
+    5.89813317647789942685e-16, 5.95193814964144415532e-16,
+    6.00837969627190832234e-16, 6.06778040933344851394e-16,
+    6.13052720872528159123e-16, 6.19708989458162555387e-16,
+    6.26804696330128439415e-16, 6.34412240712750598627e-16,
+    6.42623965954805540945e-16, 6.51560331734499356881e-16,
+    6.61382788509766415145e-16, 6.72315046250558662913e-16,
+    6.84680341756425875856e-16, 6.98971833638761995415e-16,
+    7.15999493483066421560e-16, 7.37242430179879890722e-16,
+    7.65893637080557275482e-16, 8.11384933765648418565e-16};
+
+static const double fi_double[] = {
+    1.00000000000000000000e+00, 9.77101701267671596263e-01,
+    9.59879091800106665211e-01, 9.45198953442299649730e-01,
+    9.32060075959230460718e-01, 9.19991505039347012840e-01,
+    9.08726440052130879366e-01, 8.98095921898343418910e-01,
+    8.87984660755833377088e-01, 8.78309655808917399966e-01,
+    8.69008688036857046555e-01, 8.60033621196331532488e-01,
+    8.51346258458677951353e-01, 8.42915653112204177333e-01,
+    8.34716292986883434679e-01, 8.26726833946221373317e-01,
+    8.18929191603702366642e-01, 8.11307874312656274185e-01,
+    8.03849483170964274059e-01, 7.96542330422958966274e-01,
+    7.89376143566024590648e-01, 7.82341832654802504798e-01,
+    7.75431304981187174974e-01, 7.68637315798486264740e-01,
+    7.61953346836795386565e-01, 7.55373506507096115214e-01,
+    7.48892447219156820459e-01, 7.42505296340151055290e-01,
+    7.36207598126862650112e-01, 7.29995264561476231435e-01,
+    7.23864533468630222401e-01, 7.17811932630721960535e-01,
+    7.11834248878248421200e-01, 7.05928501332754310127e-01,
+    7.00091918136511615067e-01, 6.94321916126116711609e-01,
+    6.88616083004671808432e-01, 6.82972161644994857355e-01,
+    6.77388036218773526009e-01, 6.71861719897082099173e-01,
+    6.66391343908750100056e-01, 6.60975147776663107813e-01,
+    6.55611470579697264149e-01, 6.50298743110816701574e-01,
+    6.45035480820822293424e-01, 6.39820277453056585060e-01,
+    6.34651799287623608059e-01, 6.29528779924836690007e-01,
+    6.24450015547026504592e-01, 6.19414360605834324325e-01,
+    6.14420723888913888899e-01, 6.09468064925773433949e-01,
+    6.04555390697467776029e-01, 5.99681752619125263415e-01,
+    5.94846243767987448159e-01, 5.90047996332826008015e-01,
+    5.85286179263371453274e-01, 5.80559996100790898232e-01,
+    5.75868682972353718164e-01, 5.71211506735253227163e-01,
+    5.66587763256164445025e-01, 5.61996775814524340831e-01,
+    5.57437893618765945014e-01, 5.52910490425832290562e-01,
+    5.48413963255265812791e-01, 5.43947731190026262382e-01,
+    5.39511234256952132426e-01, 5.35103932380457614215e-01,
+    5.30725304403662057062e-01, 5.26374847171684479008e-01,
+    5.22052074672321841931e-01, 5.17756517229756352272e-01,
+    5.13487720747326958914e-01, 5.09245245995747941592e-01,
+    5.05028667943468123624e-01, 5.00837575126148681903e-01,
+    4.96671569052489714213e-01, 4.92530263643868537748e-01,
+    4.88413284705458028423e-01, 4.84320269426683325253e-01,
+    4.80250865909046753544e-01, 4.76204732719505863248e-01,
+    4.72181538467730199660e-01, 4.68180961405693596422e-01,
+    4.64202689048174355069e-01, 4.60246417812842867345e-01,
+    4.56311852678716434184e-01, 4.52398706861848520777e-01,
+    4.48506701507203064949e-01, 4.44635565395739396077e-01,
+    4.40785034665803987508e-01, 4.36954852547985550526e-01,
+    4.33144769112652261445e-01, 4.29354541029441427735e-01,
+    4.25583931338021970170e-01, 4.21832709229495894654e-01,
+    4.18100649837848226120e-01, 4.14387534040891125642e-01,
+    4.10693148270188157500e-01, 4.07017284329473372217e-01,
+    4.03359739221114510510e-01, 3.99720314980197222177e-01,
+    3.96098818515832451492e-01, 3.92495061459315619512e-01,
+    3.88908860018788715696e-01, 3.85340034840077283462e-01,
+    3.81788410873393657674e-01, 3.78253817245619183840e-01,
+    3.74736087137891138443e-01, 3.71235057668239498696e-01,
+    3.67750569779032587814e-01, 3.64282468129004055601e-01,
+    3.60830600989648031529e-01, 3.57394820145780500731e-01,
+    3.53974980800076777232e-01, 3.50570941481406106455e-01,
+    3.47182563956793643900e-01, 3.43809713146850715049e-01,
+    3.40452257044521866547e-01, 3.37110066637006045021e-01,
+    3.33783015830718454708e-01, 3.30470981379163586400e-01,
+    3.27173842813601400970e-01, 3.23891482376391093290e-01,
+    3.20623784956905355514e-01, 3.17370638029913609834e-01,
+    3.14131931596337177215e-01, 3.10907558126286509559e-01,
+    3.07697412504292056035e-01, 3.04501391976649993243e-01,
+    3.01319396100803049698e-01, 2.98151326696685481377e-01,
+    2.94997087799961810184e-01, 2.91856585617095209972e-01,
+    2.88729728482182923521e-01, 2.85616426815501756042e-01,
+    2.82516593083707578948e-01, 2.79430141761637940157e-01,
+    2.76356989295668320494e-01, 2.73297054068577072172e-01,
+    2.70250256365875463072e-01, 2.67216518343561471038e-01,
+    2.64195763997261190426e-01, 2.61187919132721213522e-01,
+    2.58192911337619235290e-01, 2.55210669954661961700e-01,
+    2.52241126055942177508e-01, 2.49284212418528522415e-01,
+    2.46339863501263828249e-01, 2.43408015422750312329e-01,
+    2.40488605940500588254e-01, 2.37581574431238090606e-01,
+    2.34686861872330010392e-01, 2.31804410824338724684e-01,
+    2.28934165414680340644e-01, 2.26076071322380278694e-01,
+    2.23230075763917484855e-01, 2.20396127480151998723e-01,
+    2.17574176724331130872e-01, 2.14764175251173583536e-01,
+    2.11966076307030182324e-01, 2.09179834621125076977e-01,
+    2.06405406397880797353e-01, 2.03642749310334908452e-01,
+    2.00891822494656591136e-01, 1.98152586545775138971e-01,
+    1.95425003514134304483e-01, 1.92709036903589175926e-01,
+    1.90004651670464985713e-01, 1.87311814223800304768e-01,
+    1.84630492426799269756e-01, 1.81960655599522513892e-01,
+    1.79302274522847582272e-01, 1.76655321443734858455e-01,
+    1.74019770081838553999e-01, 1.71395595637505754327e-01,
+    1.68782774801211288285e-01, 1.66181285764481906364e-01,
+    1.63591108232365584074e-01, 1.61012223437511009516e-01,
+    1.58444614155924284882e-01, 1.55888264724479197465e-01,
+    1.53343161060262855866e-01, 1.50809290681845675763e-01,
+    1.48286642732574552861e-01, 1.45775208005994028060e-01,
+    1.43274978973513461566e-01, 1.40785949814444699690e-01,
+    1.38308116448550733057e-01, 1.35841476571253755301e-01,
+    1.33386029691669155683e-01, 1.30941777173644358090e-01,
+    1.28508722279999570981e-01, 1.26086870220185887081e-01,
+    1.23676228201596571932e-01, 1.21276805484790306533e-01,
+    1.18888613442910059947e-01, 1.16511665625610869035e-01,
+    1.14145977827838487895e-01, 1.11791568163838089811e-01,
+    1.09448457146811797824e-01, 1.07116667774683801961e-01,
+    1.04796225622487068629e-01, 1.02487158941935246892e-01,
+    1.00189498768810017482e-01, 9.79032790388624646338e-02,
+    9.56285367130089991594e-02, 9.33653119126910124859e-02,
+    9.11136480663737591268e-02, 8.88735920682758862021e-02,
+    8.66451944505580717859e-02, 8.44285095703534715916e-02,
+    8.22235958132029043366e-02, 8.00305158146630696292e-02,
+    7.78493367020961224423e-02, 7.56801303589271778804e-02,
+    7.35229737139813238622e-02, 7.13779490588904025339e-02,
+    6.92451443970067553879e-02, 6.71246538277884968737e-02,
+    6.50165779712428976156e-02, 6.29210244377581412456e-02,
+    6.08381083495398780614e-02, 5.87679529209337372930e-02,
+    5.67106901062029017391e-02, 5.46664613248889208474e-02,
+    5.26354182767921896513e-02, 5.06177238609477817000e-02,
+    4.86135532158685421122e-02, 4.66230949019303814174e-02,
+    4.46465522512944634759e-02, 4.26841449164744590750e-02,
+    4.07361106559409394401e-02, 3.88027074045261474722e-02,
+    3.68842156885673053135e-02, 3.49809414617161251737e-02,
+    3.30932194585785779961e-02, 3.12214171919203004046e-02,
+    2.93659397581333588001e-02, 2.75272356696031131329e-02,
+    2.57058040085489103443e-02, 2.39022033057958785407e-02,
+    2.21170627073088502113e-02, 2.03510962300445102935e-02,
+    1.86051212757246224594e-02, 1.68800831525431419000e-02,
+    1.51770883079353092332e-02, 1.34974506017398673818e-02,
+    1.18427578579078790488e-02, 1.02149714397014590439e-02,
+    8.61658276939872638800e-03, 7.05087547137322242369e-03,
+    5.52240329925099155545e-03, 4.03797259336302356153e-03,
+    2.60907274610215926189e-03, 1.26028593049859797236e-03};
+
+static const uint32_t ki_float[] = {
+    0x007799ECUL, 0x00000000UL, 0x006045F5UL, 0x006D1AA8UL, 0x00728FB4UL,
+    0x007592AFUL, 0x00777A5CUL, 0x0078CA38UL, 0x0079BF6BUL, 0x007A7A35UL,
+    0x007B0D2FUL, 0x007B83D4UL, 0x007BE597UL, 0x007C3788UL, 0x007C7D33UL,
+    0x007CB926UL, 0x007CED48UL, 0x007D1B08UL, 0x007D437FUL, 0x007D678BUL,
+    0x007D87DBUL, 0x007DA4FCUL, 0x007DBF61UL, 0x007DD767UL, 0x007DED5DUL,
+    0x007E0183UL, 0x007E1411UL, 0x007E2534UL, 0x007E3515UL, 0x007E43D5UL,
+    0x007E5193UL, 0x007E5E67UL, 0x007E6A69UL, 0x007E75AAUL, 0x007E803EUL,
+    0x007E8A32UL, 0x007E9395UL, 0x007E9C72UL, 0x007EA4D5UL, 0x007EACC6UL,
+    0x007EB44EUL, 0x007EBB75UL, 0x007EC243UL, 0x007EC8BCUL, 0x007ECEE8UL,
+    0x007ED4CCUL, 0x007EDA6BUL, 0x007EDFCBUL, 0x007EE4EFUL, 0x007EE9DCUL,
+    0x007EEE94UL, 0x007EF31BUL, 0x007EF774UL, 0x007EFBA0UL, 0x007EFFA3UL,
+    0x007F037FUL, 0x007F0736UL, 0x007F0ACAUL, 0x007F0E3CUL, 0x007F118FUL,
+    0x007F14C4UL, 0x007F17DCUL, 0x007F1ADAUL, 0x007F1DBDUL, 0x007F2087UL,
+    0x007F233AUL, 0x007F25D7UL, 0x007F285DUL, 0x007F2AD0UL, 0x007F2D2EUL,
+    0x007F2F7AUL, 0x007F31B3UL, 0x007F33DCUL, 0x007F35F3UL, 0x007F37FBUL,
+    0x007F39F3UL, 0x007F3BDCUL, 0x007F3DB7UL, 0x007F3F84UL, 0x007F4145UL,
+    0x007F42F8UL, 0x007F449FUL, 0x007F463AUL, 0x007F47CAUL, 0x007F494EUL,
+    0x007F4AC8UL, 0x007F4C38UL, 0x007F4D9DUL, 0x007F4EF9UL, 0x007F504CUL,
+    0x007F5195UL, 0x007F52D5UL, 0x007F540DUL, 0x007F553DUL, 0x007F5664UL,
+    0x007F5784UL, 0x007F589CUL, 0x007F59ACUL, 0x007F5AB5UL, 0x007F5BB8UL,
+    0x007F5CB3UL, 0x007F5DA8UL, 0x007F5E96UL, 0x007F5F7EUL, 0x007F605FUL,
+    0x007F613BUL, 0x007F6210UL, 0x007F62E0UL, 0x007F63AAUL, 0x007F646FUL,
+    0x007F652EUL, 0x007F65E8UL, 0x007F669CUL, 0x007F674CUL, 0x007F67F6UL,
+    0x007F689CUL, 0x007F693CUL, 0x007F69D9UL, 0x007F6A70UL, 0x007F6B03UL,
+    0x007F6B91UL, 0x007F6C1BUL, 0x007F6CA0UL, 0x007F6D21UL, 0x007F6D9EUL,
+    0x007F6E17UL, 0x007F6E8CUL, 0x007F6EFCUL, 0x007F6F68UL, 0x007F6FD1UL,
+    0x007F7035UL, 0x007F7096UL, 0x007F70F3UL, 0x007F714CUL, 0x007F71A1UL,
+    0x007F71F2UL, 0x007F723FUL, 0x007F7289UL, 0x007F72CFUL, 0x007F7312UL,
+    0x007F7350UL, 0x007F738BUL, 0x007F73C3UL, 0x007F73F6UL, 0x007F7427UL,
+    0x007F7453UL, 0x007F747CUL, 0x007F74A1UL, 0x007F74C3UL, 0x007F74E0UL,
+    0x007F74FBUL, 0x007F7511UL, 0x007F7524UL, 0x007F7533UL, 0x007F753FUL,
+    0x007F7546UL, 0x007F754AUL, 0x007F754BUL, 0x007F7547UL, 0x007F753FUL,
+    0x007F7534UL, 0x007F7524UL, 0x007F7511UL, 0x007F74F9UL, 0x007F74DEUL,
+    0x007F74BEUL, 0x007F749AUL, 0x007F7472UL, 0x007F7445UL, 0x007F7414UL,
+    0x007F73DFUL, 0x007F73A5UL, 0x007F7366UL, 0x007F7323UL, 0x007F72DAUL,
+    0x007F728DUL, 0x007F723AUL, 0x007F71E3UL, 0x007F7186UL, 0x007F7123UL,
+    0x007F70BBUL, 0x007F704DUL, 0x007F6FD9UL, 0x007F6F5FUL, 0x007F6EDFUL,
+    0x007F6E58UL, 0x007F6DCBUL, 0x007F6D37UL, 0x007F6C9CUL, 0x007F6BF9UL,
+    0x007F6B4FUL, 0x007F6A9CUL, 0x007F69E2UL, 0x007F691FUL, 0x007F6854UL,
+    0x007F677FUL, 0x007F66A1UL, 0x007F65B8UL, 0x007F64C6UL, 0x007F63C8UL,
+    0x007F62C0UL, 0x007F61ABUL, 0x007F608AUL, 0x007F5F5DUL, 0x007F5E21UL,
+    0x007F5CD8UL, 0x007F5B7FUL, 0x007F5A17UL, 0x007F589EUL, 0x007F5713UL,
+    0x007F5575UL, 0x007F53C4UL, 0x007F51FEUL, 0x007F5022UL, 0x007F4E2FUL,
+    0x007F4C22UL, 0x007F49FAUL, 0x007F47B6UL, 0x007F4553UL, 0x007F42CFUL,
+    0x007F4028UL, 0x007F3D5AUL, 0x007F3A64UL, 0x007F3741UL, 0x007F33EDUL,
+    0x007F3065UL, 0x007F2CA4UL, 0x007F28A4UL, 0x007F245FUL, 0x007F1FCEUL,
+    0x007F1AEAUL, 0x007F15A9UL, 0x007F1000UL, 0x007F09E4UL, 0x007F0346UL,
+    0x007EFC16UL, 0x007EF43EUL, 0x007EEBA8UL, 0x007EE237UL, 0x007ED7C8UL,
+    0x007ECC2FUL, 0x007EBF37UL, 0x007EB09DUL, 0x007EA00AUL, 0x007E8D0DUL,
+    0x007E7710UL, 0x007E5D47UL, 0x007E3E93UL, 0x007E1959UL, 0x007DEB2CUL,
+    0x007DB036UL, 0x007D6203UL, 0x007CF4B9UL, 0x007C4FD2UL, 0x007B3630UL,
+    0x0078D2D2UL};
+
+static const float wi_float[] = {
+    4.66198677960027669255e-07f, 2.56588335019207033255e-08f,
+    3.41146697750176784592e-08f, 4.00230311410932959821e-08f,
+    4.47179475877737745459e-08f, 4.86837785973537366722e-08f,
+    5.21562578925932412861e-08f, 5.52695199001886257153e-08f,
+    5.81078488992733116465e-08f, 6.07279932024587421409e-08f,
+    6.31701613261172047795e-08f, 6.54639842900233842742e-08f,
+    6.76319905583641815324e-08f, 6.96917493470166688656e-08f,
+    7.16572544283857476692e-08f, 7.35398519048393832969e-08f,
+    7.53488822443557479279e-08f, 7.70921367281667127885e-08f,
+    7.87761895947956022626e-08f, 8.04066446825615346857e-08f,
+    8.19883218760237408659e-08f, 8.35254002936857088917e-08f,
+    8.50215298165053411740e-08f, 8.64799190652369040985e-08f,
+    8.79034055989140110861e-08f, 8.92945125124233511541e-08f,
+    9.06554945027956262312e-08f, 9.19883756905278607229e-08f,
+    9.32949809202232869780e-08f, 9.45769618559625849039e-08f,
+    9.58358188855612866442e-08f, 9.70729196232813152662e-08f,
+    9.82895146313061088986e-08f, 9.94867508514382224721e-08f,
+    1.00665683139461669691e-07f, 1.01827284217853923044e-07f,
+    1.02972453302539369464e-07f, 1.04102023612124921572e-07f,
+    1.05216768930574060431e-07f, 1.06317409364335657741e-07f,
+    1.07404616410877866490e-07f, 1.08479017436113134283e-07f,
+    1.09541199642370962438e-07f, 1.10591713595628691212e-07f,
+    1.11631076370069356306e-07f, 1.12659774359245895023e-07f,
+    1.13678265795837113569e-07f, 1.14686983015899673063e-07f,
+    1.15686334498432158725e-07f, 1.16676706706789039179e-07f,
+    1.17658465754873988919e-07f, 1.18631958917986203582e-07f,
+    1.19597516005596215528e-07f, 1.20555450611113917226e-07f,
+    1.21506061251817163689e-07f, 1.22449632410483948386e-07f,
+    1.23386435488872536840e-07f, 1.24316729681986364321e-07f,
+    1.25240762781015530062e-07f, 1.26158771911939892267e-07f,
+    1.27070984215989333455e-07f, 1.27977617477468922011e-07f,
+    1.28878880703854958297e-07f, 1.29774974662539874521e-07f,
+    1.30666092378141980504e-07f, 1.31552419593887221722e-07f,
+    1.32434135200211397569e-07f, 1.33311411633413359243e-07f,
+    1.34184415246907777059e-07f, 1.35053306657377859830e-07f,
+    1.35918241067904315860e-07f, 1.36779368569952053923e-07f,
+    1.37636834425917531047e-07f, 1.38490779333783508675e-07f,
+    1.39341339675287344817e-07f, 1.40188647748881762555e-07f,
+    1.41032831988654882776e-07f, 1.41874017170273235693e-07f,
+    1.42712324604921442006e-07f, 1.43547872322127921816e-07f,
+    1.44380775242292721080e-07f, 1.45211145339665544509e-07f,
+    1.46039091796461362146e-07f, 1.46864721148745476208e-07f,
+    1.47688137424670065700e-07f, 1.48509442275598857119e-07f,
+    1.49328735100614641423e-07f, 1.50146113164867617390e-07f,
+    1.50961671712187416111e-07f, 1.51775504072350982845e-07f,
+    1.52587701763369746341e-07f, 1.53398354589133671168e-07f,
+    1.54207550732725568797e-07f, 1.55015376845697999657e-07f,
+    1.55821918133584372604e-07f, 1.56627258437898192833e-07f,
+    1.57431480314857468671e-07f, 1.58234665111056041043e-07f,
+    1.59036893036289199880e-07f, 1.59838243233728855017e-07f,
+    1.60638793847630850137e-07f, 1.61438622088746393909e-07f,
+    1.62237804297600106296e-07f, 1.63036416005787357730e-07f,
+    1.63834531995435479082e-07f, 1.64632226356965902954e-07f,
+    1.65429572545287097020e-07f, 1.66226643434541294491e-07f,
+    1.67023511371523209274e-07f, 1.67820248227882200051e-07f,
+    1.68616925451215588827e-07f, 1.69413614115155757272e-07f,
+    1.70210384968549673733e-07f, 1.71007308483826142122e-07f,
+    1.71804454904642543391e-07f, 1.72601894292900061024e-07f,
+    1.73399696575213681990e-07f, 1.74197931588920988271e-07f,
+    1.74996669127712165834e-07f, 1.75795978986961275677e-07f,
+    1.76595931008838063924e-07f, 1.77396595127278238022e-07f,
+    1.78198041412889183130e-07f, 1.79000340117867431104e-07f,
+    1.79803561721004406185e-07f, 1.80607776972855859813e-07f,
+    1.81413056941151359868e-07f, 1.82219473056520464354e-07f,
+    1.83027097158612474240e-07f, 1.83836001542687613069e-07f,
+    1.84646259006759307383e-07f, 1.85457942899367347876e-07f,
+    1.86271127168064649331e-07f, 1.87085886408701333260e-07f,
+    1.87902295915592424729e-07f, 1.88720431732658022414e-07f,
+    1.89540370705627262627e-07f, 1.90362190535400839128e-07f,
+    1.91185969832669990437e-07f, 1.92011788173893651535e-07f,
+    1.92839726158739913768e-07f, 1.93669865469102145482e-07f,
+    1.94502288929804890433e-07f, 1.95337080571120616772e-07f,
+    1.96174325693223683314e-07f, 1.97014110932714374919e-07f,
+    1.97856524331352952716e-07f, 1.98701655407150388211e-07f,
+    1.99549595227971635348e-07f, 2.00400436487814600236e-07f,
+    2.01254273585938820883e-07f, 2.02111202709026498408e-07f,
+    2.02971321916571014951e-07f, 2.03834731229698846698e-07f,
+    2.04701532723644121196e-07f, 2.05571830624108885378e-07f,
+    2.06445731407757185541e-07f, 2.07323343907107312957e-07f,
+    2.08204779420104330037e-07f, 2.09090151824673600213e-07f,
+    2.09979577698577670508e-07f, 2.10873176444920111011e-07f,
+    2.11771070423665379388e-07f, 2.12673385089569268965e-07f,
+    2.13580249136944118603e-07f, 2.14491794651713402832e-07f,
+    2.15408157271244625533e-07f, 2.16329476352486921685e-07f,
+    2.17255895148978920488e-07f, 2.18187560997337924713e-07f,
+    2.19124625513888206785e-07f, 2.20067244802139479285e-07f,
+    2.21015579671883851683e-07f, 2.21969795870742159701e-07f,
+    2.22930064329060010376e-07f, 2.23896561419128954210e-07f,
+    2.24869469229791575583e-07f, 2.25848975857580322189e-07f,
+    2.26835275715640744118e-07f, 2.27828569861799901001e-07f,
+    2.28829066347263833069e-07f, 2.29836980587561823183e-07f,
+    2.30852535757505260518e-07f, 2.31875963212094114516e-07f,
+    2.32907502935486642699e-07f, 2.33947404020352726160e-07f,
+    2.34995925180156140289e-07f, 2.36053335297164516378e-07f,
+    2.37119914009265667728e-07f, 2.38195952338983970691e-07f,
+    2.39281753368440712742e-07f, 2.40377632964396957621e-07f,
+    2.41483920557958384709e-07f, 2.42600959984018662258e-07f,
+    2.43729110386077326413e-07f, 2.44868747192698939290e-07f,
+    2.46020263172594533433e-07f, 2.47184069576113545901e-07f,
+    2.48360597371852893654e-07f, 2.49550298588131851232e-07f,
+    2.50753647770270890721e-07f, 2.51971143565970967140e-07f,
+    2.53203310452642767375e-07f, 2.54450700622322097890e-07f,
+    2.55713896041856770961e-07f, 2.56993510708419870887e-07f,
+    2.58290193123138874550e-07f, 2.59604629008804833146e-07f,
+    2.60937544301314385690e-07f, 2.62289708448800566945e-07f,
+    2.63661938057441759882e-07f, 2.65055100928844238758e-07f,
+    2.66470120540847889467e-07f, 2.67907981031821866252e-07f,
+    2.69369732758258246335e-07f, 2.70856498507068313229e-07f,
+    2.72369480457841388042e-07f, 2.73909968006952220135e-07f,
+    2.75479346585437289399e-07f, 2.77079107626811561009e-07f,
+    2.78710859870496796972e-07f, 2.80376342222588603820e-07f,
+    2.82077438439999912690e-07f, 2.83816193958769527230e-07f,
+    2.85594835255375795814e-07f, 2.87415792215003905739e-07f,
+    2.89281724087851835900e-07f, 2.91195549750371467233e-07f,
+    2.93160483161771875581e-07f, 2.95180075129332912389e-07f,
+    2.97258262785797916083e-07f, 2.99399428561531794298e-07f,
+    3.01608470935804138388e-07f, 3.03890889921758510417e-07f,
+    3.06252891144972267537e-07f, 3.08701513613258141075e-07f,
+    3.11244787989714509378e-07f, 3.13891934589336184321e-07f,
+    3.16653613755314681314e-07f, 3.19542246256559459667e-07f,
+    3.22572428717978242099e-07f, 3.25761480217458181578e-07f,
+    3.29130173358915628534e-07f, 3.32703730345002116955e-07f,
+    3.36513208964639108346e-07f, 3.40597478255417943913e-07f,
+    3.45006114675213401550e-07f, 3.49803789521323211592e-07f,
+    3.55077180848341416206e-07f, 3.60946392031859609868e-07f,
+    3.67584959507244041831e-07f, 3.75257645787954431030e-07f,
+    3.84399301057791926300e-07f, 3.95804015855768440983e-07f,
+    4.11186015434435801956e-07f, 4.35608969373823260746e-07f};
+
+static const float fi_float[] = {
+    1.00000000000000000000e+00f, 9.77101701267671596263e-01f,
+    9.59879091800106665211e-01f, 9.45198953442299649730e-01f,
+    9.32060075959230460718e-01f, 9.19991505039347012840e-01f,
+    9.08726440052130879366e-01f, 8.98095921898343418910e-01f,
+    8.87984660755833377088e-01f, 8.78309655808917399966e-01f,
+    8.69008688036857046555e-01f, 8.60033621196331532488e-01f,
+    8.51346258458677951353e-01f, 8.42915653112204177333e-01f,
+    8.34716292986883434679e-01f, 8.26726833946221373317e-01f,
+    8.18929191603702366642e-01f, 8.11307874312656274185e-01f,
+    8.03849483170964274059e-01f, 7.96542330422958966274e-01f,
+    7.89376143566024590648e-01f, 7.82341832654802504798e-01f,
+    7.75431304981187174974e-01f, 7.68637315798486264740e-01f,
+    7.61953346836795386565e-01f, 7.55373506507096115214e-01f,
+    7.48892447219156820459e-01f, 7.42505296340151055290e-01f,
+    7.36207598126862650112e-01f, 7.29995264561476231435e-01f,
+    7.23864533468630222401e-01f, 7.17811932630721960535e-01f,
+    7.11834248878248421200e-01f, 7.05928501332754310127e-01f,
+    7.00091918136511615067e-01f, 6.94321916126116711609e-01f,
+    6.88616083004671808432e-01f, 6.82972161644994857355e-01f,
+    6.77388036218773526009e-01f, 6.71861719897082099173e-01f,
+    6.66391343908750100056e-01f, 6.60975147776663107813e-01f,
+    6.55611470579697264149e-01f, 6.50298743110816701574e-01f,
+    6.45035480820822293424e-01f, 6.39820277453056585060e-01f,
+    6.34651799287623608059e-01f, 6.29528779924836690007e-01f,
+    6.24450015547026504592e-01f, 6.19414360605834324325e-01f,
+    6.14420723888913888899e-01f, 6.09468064925773433949e-01f,
+    6.04555390697467776029e-01f, 5.99681752619125263415e-01f,
+    5.94846243767987448159e-01f, 5.90047996332826008015e-01f,
+    5.85286179263371453274e-01f, 5.80559996100790898232e-01f,
+    5.75868682972353718164e-01f, 5.71211506735253227163e-01f,
+    5.66587763256164445025e-01f, 5.61996775814524340831e-01f,
+    5.57437893618765945014e-01f, 5.52910490425832290562e-01f,
+    5.48413963255265812791e-01f, 5.43947731190026262382e-01f,
+    5.39511234256952132426e-01f, 5.35103932380457614215e-01f,
+    5.30725304403662057062e-01f, 5.26374847171684479008e-01f,
+    5.22052074672321841931e-01f, 5.17756517229756352272e-01f,
+    5.13487720747326958914e-01f, 5.09245245995747941592e-01f,
+    5.05028667943468123624e-01f, 5.00837575126148681903e-01f,
+    4.96671569052489714213e-01f, 4.92530263643868537748e-01f,
+    4.88413284705458028423e-01f, 4.84320269426683325253e-01f,
+    4.80250865909046753544e-01f, 4.76204732719505863248e-01f,
+    4.72181538467730199660e-01f, 4.68180961405693596422e-01f,
+    4.64202689048174355069e-01f, 4.60246417812842867345e-01f,
+    4.56311852678716434184e-01f, 4.52398706861848520777e-01f,
+    4.48506701507203064949e-01f, 4.44635565395739396077e-01f,
+    4.40785034665803987508e-01f, 4.36954852547985550526e-01f,
+    4.33144769112652261445e-01f, 4.29354541029441427735e-01f,
+    4.25583931338021970170e-01f, 4.21832709229495894654e-01f,
+    4.18100649837848226120e-01f, 4.14387534040891125642e-01f,
+    4.10693148270188157500e-01f, 4.07017284329473372217e-01f,
+    4.03359739221114510510e-01f, 3.99720314980197222177e-01f,
+    3.96098818515832451492e-01f, 3.92495061459315619512e-01f,
+    3.88908860018788715696e-01f, 3.85340034840077283462e-01f,
+    3.81788410873393657674e-01f, 3.78253817245619183840e-01f,
+    3.74736087137891138443e-01f, 3.71235057668239498696e-01f,
+    3.67750569779032587814e-01f, 3.64282468129004055601e-01f,
+    3.60830600989648031529e-01f, 3.57394820145780500731e-01f,
+    3.53974980800076777232e-01f, 3.50570941481406106455e-01f,
+    3.47182563956793643900e-01f, 3.43809713146850715049e-01f,
+    3.40452257044521866547e-01f, 3.37110066637006045021e-01f,
+    3.33783015830718454708e-01f, 3.30470981379163586400e-01f,
+    3.27173842813601400970e-01f, 3.23891482376391093290e-01f,
+    3.20623784956905355514e-01f, 3.17370638029913609834e-01f,
+    3.14131931596337177215e-01f, 3.10907558126286509559e-01f,
+    3.07697412504292056035e-01f, 3.04501391976649993243e-01f,
+    3.01319396100803049698e-01f, 2.98151326696685481377e-01f,
+    2.94997087799961810184e-01f, 2.91856585617095209972e-01f,
+    2.88729728482182923521e-01f, 2.85616426815501756042e-01f,
+    2.82516593083707578948e-01f, 2.79430141761637940157e-01f,
+    2.76356989295668320494e-01f, 2.73297054068577072172e-01f,
+    2.70250256365875463072e-01f, 2.67216518343561471038e-01f,
+    2.64195763997261190426e-01f, 2.61187919132721213522e-01f,
+    2.58192911337619235290e-01f, 2.55210669954661961700e-01f,
+    2.52241126055942177508e-01f, 2.49284212418528522415e-01f,
+    2.46339863501263828249e-01f, 2.43408015422750312329e-01f,
+    2.40488605940500588254e-01f, 2.37581574431238090606e-01f,
+    2.34686861872330010392e-01f, 2.31804410824338724684e-01f,
+    2.28934165414680340644e-01f, 2.26076071322380278694e-01f,
+    2.23230075763917484855e-01f, 2.20396127480151998723e-01f,
+    2.17574176724331130872e-01f, 2.14764175251173583536e-01f,
+    2.11966076307030182324e-01f, 2.09179834621125076977e-01f,
+    2.06405406397880797353e-01f, 2.03642749310334908452e-01f,
+    2.00891822494656591136e-01f, 1.98152586545775138971e-01f,
+    1.95425003514134304483e-01f, 1.92709036903589175926e-01f,
+    1.90004651670464985713e-01f, 1.87311814223800304768e-01f,
+    1.84630492426799269756e-01f, 1.81960655599522513892e-01f,
+    1.79302274522847582272e-01f, 1.76655321443734858455e-01f,
+    1.74019770081838553999e-01f, 1.71395595637505754327e-01f,
+    1.68782774801211288285e-01f, 1.66181285764481906364e-01f,
+    1.63591108232365584074e-01f, 1.61012223437511009516e-01f,
+    1.58444614155924284882e-01f, 1.55888264724479197465e-01f,
+    1.53343161060262855866e-01f, 1.50809290681845675763e-01f,
+    1.48286642732574552861e-01f, 1.45775208005994028060e-01f,
+    1.43274978973513461566e-01f, 1.40785949814444699690e-01f,
+    1.38308116448550733057e-01f, 1.35841476571253755301e-01f,
+    1.33386029691669155683e-01f, 1.30941777173644358090e-01f,
+    1.28508722279999570981e-01f, 1.26086870220185887081e-01f,
+    1.23676228201596571932e-01f, 1.21276805484790306533e-01f,
+    1.18888613442910059947e-01f, 1.16511665625610869035e-01f,
+    1.14145977827838487895e-01f, 1.11791568163838089811e-01f,
+    1.09448457146811797824e-01f, 1.07116667774683801961e-01f,
+    1.04796225622487068629e-01f, 1.02487158941935246892e-01f,
+    1.00189498768810017482e-01f, 9.79032790388624646338e-02f,
+    9.56285367130089991594e-02f, 9.33653119126910124859e-02f,
+    9.11136480663737591268e-02f, 8.88735920682758862021e-02f,
+    8.66451944505580717859e-02f, 8.44285095703534715916e-02f,
+    8.22235958132029043366e-02f, 8.00305158146630696292e-02f,
+    7.78493367020961224423e-02f, 7.56801303589271778804e-02f,
+    7.35229737139813238622e-02f, 7.13779490588904025339e-02f,
+    6.92451443970067553879e-02f, 6.71246538277884968737e-02f,
+    6.50165779712428976156e-02f, 6.29210244377581412456e-02f,
+    6.08381083495398780614e-02f, 5.87679529209337372930e-02f,
+    5.67106901062029017391e-02f, 5.46664613248889208474e-02f,
+    5.26354182767921896513e-02f, 5.06177238609477817000e-02f,
+    4.86135532158685421122e-02f, 4.66230949019303814174e-02f,
+    4.46465522512944634759e-02f, 4.26841449164744590750e-02f,
+    4.07361106559409394401e-02f, 3.88027074045261474722e-02f,
+    3.68842156885673053135e-02f, 3.49809414617161251737e-02f,
+    3.30932194585785779961e-02f, 3.12214171919203004046e-02f,
+    2.93659397581333588001e-02f, 2.75272356696031131329e-02f,
+    2.57058040085489103443e-02f, 2.39022033057958785407e-02f,
+    2.21170627073088502113e-02f, 2.03510962300445102935e-02f,
+    1.86051212757246224594e-02f, 1.68800831525431419000e-02f,
+    1.51770883079353092332e-02f, 1.34974506017398673818e-02f,
+    1.18427578579078790488e-02f, 1.02149714397014590439e-02f,
+    8.61658276939872638800e-03f, 7.05087547137322242369e-03f,
+    5.52240329925099155545e-03f, 4.03797259336302356153e-03f,
+    2.60907274610215926189e-03f, 1.26028593049859797236e-03f};
+
+static const uint64_t ke_double[] = {
+    0x001C5214272497C6, 0x0000000000000000, 0x00137D5BD79C317E,
+    0x00186EF58E3F3C10, 0x001A9BB7320EB0AE, 0x001BD127F719447C,
+    0x001C951D0F88651A, 0x001D1BFE2D5C3972, 0x001D7E5BD56B18B2,
+    0x001DC934DD172C70, 0x001E0409DFAC9DC8, 0x001E337B71D47836,
+    0x001E5A8B177CB7A2, 0x001E7B42096F046C, 0x001E970DAF08AE3E,
+    0x001EAEF5B14EF09E, 0x001EC3BD07B46556, 0x001ED5F6F08799CE,
+    0x001EE614AE6E5688, 0x001EF46ECA361CD0, 0x001F014B76DDD4A4,
+    0x001F0CE313A796B6, 0x001F176369F1F77A, 0x001F20F20C452570,
+    0x001F29AE1951A874, 0x001F31B18FB95532, 0x001F39125157C106,
+    0x001F3FE2EB6E694C, 0x001F463332D788FA, 0x001F4C10BF1D3A0E,
+    0x001F51874C5C3322, 0x001F56A109C3ECC0, 0x001F5B66D9099996,
+    0x001F5FE08210D08C, 0x001F6414DD445772, 0x001F6809F6859678,
+    0x001F6BC52A2B02E6, 0x001F6F4B3D32E4F4, 0x001F72A07190F13A,
+    0x001F75C8974D09D6, 0x001F78C71B045CC0, 0x001F7B9F12413FF4,
+    0x001F7E5346079F8A, 0x001F80E63BE21138, 0x001F835A3DAD9162,
+    0x001F85B16056B912, 0x001F87ED89B24262, 0x001F8A10759374FA,
+    0x001F8C1BBA3D39AC, 0x001F8E10CC45D04A, 0x001F8FF102013E16,
+    0x001F91BD968358E0, 0x001F9377AC47AFD8, 0x001F95204F8B64DA,
+    0x001F96B878633892, 0x001F98410C968892, 0x001F99BAE146BA80,
+    0x001F9B26BC697F00, 0x001F9C85561B717A, 0x001F9DD759CFD802,
+    0x001F9F1D6761A1CE, 0x001FA058140936C0, 0x001FA187EB3A3338,
+    0x001FA2AD6F6BC4FC, 0x001FA3C91ACE0682, 0x001FA4DB5FEE6AA2,
+    0x001FA5E4AA4D097C, 0x001FA6E55EE46782, 0x001FA7DDDCA51EC4,
+    0x001FA8CE7CE6A874, 0x001FA9B793CE5FEE, 0x001FAA9970ADB858,
+    0x001FAB745E588232, 0x001FAC48A3740584, 0x001FAD1682BF9FE8,
+    0x001FADDE3B5782C0, 0x001FAEA008F21D6C, 0x001FAF5C2418B07E,
+    0x001FB012C25B7A12, 0x001FB0C41681DFF4, 0x001FB17050B6F1FA,
+    0x001FB2179EB2963A, 0x001FB2BA2BDFA84A, 0x001FB358217F4E18,
+    0x001FB3F1A6C9BE0C, 0x001FB486E10CACD6, 0x001FB517F3C793FC,
+    0x001FB5A500C5FDAA, 0x001FB62E2837FE58, 0x001FB6B388C9010A,
+    0x001FB7353FB50798, 0x001FB7B368DC7DA8, 0x001FB82E1ED6BA08,
+    0x001FB8A57B0347F6, 0x001FB919959A0F74, 0x001FB98A85BA7204,
+    0x001FB9F861796F26, 0x001FBA633DEEE286, 0x001FBACB2F41EC16,
+    0x001FBB3048B49144, 0x001FBB929CAEA4E2, 0x001FBBF23CC8029E,
+    0x001FBC4F39D22994, 0x001FBCA9A3E140D4, 0x001FBD018A548F9E,
+    0x001FBD56FBDE729C, 0x001FBDAA068BD66A, 0x001FBDFAB7CB3F40,
+    0x001FBE491C7364DE, 0x001FBE9540C9695E, 0x001FBEDF3086B128,
+    0x001FBF26F6DE6174, 0x001FBF6C9E828AE2, 0x001FBFB031A904C4,
+    0x001FBFF1BA0FFDB0, 0x001FC03141024588, 0x001FC06ECF5B54B2,
+    0x001FC0AA6D8B1426, 0x001FC0E42399698A, 0x001FC11BF9298A64,
+    0x001FC151F57D1942, 0x001FC1861F770F4A, 0x001FC1B87D9E74B4,
+    0x001FC1E91620EA42, 0x001FC217EED505DE, 0x001FC2450D3C83FE,
+    0x001FC27076864FC2, 0x001FC29A2F90630E, 0x001FC2C23CE98046,
+    0x001FC2E8A2D2C6B4, 0x001FC30D654122EC, 0x001FC33087DE9C0E,
+    0x001FC3520E0B7EC6, 0x001FC371FADF66F8, 0x001FC390512A2886,
+    0x001FC3AD137497FA, 0x001FC3C844013348, 0x001FC3E1E4CCAB40,
+    0x001FC3F9F78E4DA8, 0x001FC4107DB85060, 0x001FC4257877FD68,
+    0x001FC438E8B5BFC6, 0x001FC44ACF15112A, 0x001FC45B2BF447E8,
+    0x001FC469FF6C4504, 0x001FC477495001B2, 0x001FC483092BFBB8,
+    0x001FC48D3E457FF6, 0x001FC495E799D21A, 0x001FC49D03DD30B0,
+    0x001FC4A29179B432, 0x001FC4A68E8E07FC, 0x001FC4A8F8EBFB8C,
+    0x001FC4A9CE16EA9E, 0x001FC4A90B41FA34, 0x001FC4A6AD4E28A0,
+    0x001FC4A2B0C82E74, 0x001FC49D11E62DE2, 0x001FC495CC852DF4,
+    0x001FC48CDC265EC0, 0x001FC4823BEC237A, 0x001FC475E696DEE6,
+    0x001FC467D6817E82, 0x001FC458059DC036, 0x001FC4466D702E20,
+    0x001FC433070BCB98, 0x001FC41DCB0D6E0E, 0x001FC406B196BBF6,
+    0x001FC3EDB248CB62, 0x001FC3D2C43E593C, 0x001FC3B5DE0591B4,
+    0x001FC396F599614C, 0x001FC376005A4592, 0x001FC352F3069370,
+    0x001FC32DC1B22818, 0x001FC3065FBD7888, 0x001FC2DCBFCBF262,
+    0x001FC2B0D3B99F9E, 0x001FC2828C8FFCF0, 0x001FC251DA79F164,
+    0x001FC21EACB6D39E, 0x001FC1E8F18C6756, 0x001FC1B09637BB3C,
+    0x001FC17586DCCD10, 0x001FC137AE74D6B6, 0x001FC0F6F6BB2414,
+    0x001FC0B348184DA4, 0x001FC06C898BAFF0, 0x001FC022A092F364,
+    0x001FBFD5710F72B8, 0x001FBF84DD29488E, 0x001FBF30C52FC60A,
+    0x001FBED907770CC6, 0x001FBE7D80327DDA, 0x001FBE1E094BA614,
+    0x001FBDBA7A354408, 0x001FBD52A7B9F826, 0x001FBCE663C6201A,
+    0x001FBC757D2C4DE4, 0x001FBBFFBF63B7AA, 0x001FBB84F23FE6A2,
+    0x001FBB04D9A0D18C, 0x001FBA7F351A70AC, 0x001FB9F3BF92B618,
+    0x001FB9622ED4ABFC, 0x001FB8CA33174A16, 0x001FB82B76765B54,
+    0x001FB7859C5B895C, 0x001FB6D840D55594, 0x001FB622F7D96942,
+    0x001FB5654C6F37E0, 0x001FB49EBFBF69D2, 0x001FB3CEC803E746,
+    0x001FB2F4CF539C3E, 0x001FB21032442852, 0x001FB1203E5A9604,
+    0x001FB0243042E1C2, 0x001FAF1B31C479A6, 0x001FAE045767E104,
+    0x001FACDE9DBF2D72, 0x001FABA8E640060A, 0x001FAA61F399FF28,
+    0x001FA908656F66A2, 0x001FA79AB3508D3C, 0x001FA61726D1F214,
+    0x001FA47BD48BEA00, 0x001FA2C693C5C094, 0x001FA0F4F47DF314,
+    0x001F9F04336BBE0A, 0x001F9CF12B79F9BC, 0x001F9AB84415ABC4,
+    0x001F98555B782FB8, 0x001F95C3ABD03F78, 0x001F92FDA9CEF1F2,
+    0x001F8FFCDA9AE41C, 0x001F8CB99E7385F8, 0x001F892AEC479606,
+    0x001F8545F904DB8E, 0x001F80FDC336039A, 0x001F7C427839E926,
+    0x001F7700A3582ACC, 0x001F71200F1A241C, 0x001F6A8234B7352A,
+    0x001F630000A8E266, 0x001F5A66904FE3C4, 0x001F50724ECE1172,
+    0x001F44C7665C6FDA, 0x001F36E5A38A59A2, 0x001F26143450340A,
+    0x001F113E047B0414, 0x001EF6AEFA57CBE6, 0x001ED38CA188151E,
+    0x001EA2A61E122DB0, 0x001E5961C78B267C, 0x001DDDF62BAC0BB0,
+    0x001CDB4DD9E4E8C0};
+
+static const double we_double[] = {
+    9.655740063209182975e-16, 7.089014243955414331e-18,
+    1.163941249669122378e-17, 1.524391512353216015e-17,
+    1.833284885723743916e-17, 2.108965109464486630e-17,
+    2.361128077843138196e-17, 2.595595772310893952e-17,
+    2.816173554197752338e-17, 3.025504130321382330e-17,
+    3.225508254836375280e-17, 3.417632340185027033e-17,
+    3.602996978734452488e-17, 3.782490776869649048e-17,
+    3.956832198097553231e-17, 4.126611778175946428e-17,
+    4.292321808442525631e-17, 4.454377743282371417e-17,
+    4.613133981483185932e-17, 4.768895725264635940e-17,
+    4.921928043727962847e-17, 5.072462904503147014e-17,
+    5.220704702792671737e-17, 5.366834661718192181e-17,
+    5.511014372835094717e-17, 5.653388673239667134e-17,
+    5.794088004852766616e-17, 5.933230365208943081e-17,
+    6.070922932847179572e-17, 6.207263431163193485e-17,
+    6.342341280303076511e-17, 6.476238575956142121e-17,
+    6.609030925769405241e-17, 6.740788167872722244e-17,
+    6.871574991183812442e-17, 7.001451473403929616e-17,
+    7.130473549660643409e-17, 7.258693422414648352e-17,
+    7.386159921381791997e-17, 7.512918820723728089e-17,
+    7.639013119550825792e-17, 7.764483290797848102e-17,
+    7.889367502729790548e-17, 8.013701816675454434e-17,
+    8.137520364041762206e-17, 8.260855505210038174e-17,
+    8.383737972539139383e-17, 8.506196999385323132e-17,
+    8.628260436784112996e-17, 8.749954859216182511e-17,
+    8.871305660690252281e-17, 8.992337142215357066e-17,
+    9.113072591597909173e-17, 9.233534356381788123e-17,
+    9.353743910649128938e-17, 9.473721916312949566e-17,
+    9.593488279457997317e-17, 9.713062202221521206e-17,
+    9.832462230649511362e-17, 9.951706298915071878e-17,
+    1.007081177024294931e-16, 1.018979547484694078e-16,
+    1.030867374515421954e-16, 1.042746244856188556e-16,
+    1.054617701794576406e-16, 1.066483248011914702e-16,
+    1.078344348241948498e-16, 1.090202431758350473e-16,
+    1.102058894705578110e-16, 1.113915102286197502e-16,
+    1.125772390816567488e-16, 1.137632069661684705e-16,
+    1.149495423059009298e-16, 1.161363711840218308e-16,
+    1.173238175059045788e-16, 1.185120031532669434e-16,
+    1.197010481303465158e-16, 1.208910707027385520e-16,
+    1.220821875294706151e-16, 1.232745137888415193e-16,
+    1.244681632985112523e-16, 1.256632486302898513e-16,
+    1.268598812200397542e-16, 1.280581714730749379e-16,
+    1.292582288654119552e-16, 1.304601620412028847e-16,
+    1.316640789066572582e-16, 1.328700867207380889e-16,
+    1.340782921828999433e-16, 1.352888015181175458e-16,
+    1.365017205594397770e-16, 1.377171548282880964e-16,
+    1.389352096127063919e-16, 1.401559900437571538e-16,
+    1.413796011702485188e-16, 1.426061480319665444e-16,
+    1.438357357315790180e-16, 1.450684695053687684e-16,
+    1.463044547929475721e-16, 1.475437973060951633e-16,
+    1.487866030968626066e-16, 1.500329786250736949e-16,
+    1.512830308253539427e-16, 1.525368671738125550e-16,
+    1.537945957544996933e-16, 1.550563253257577148e-16,
+    1.563221653865837505e-16, 1.575922262431176140e-16,
+    1.588666190753684151e-16, 1.601454560042916733e-16,
+    1.614288501593278662e-16, 1.627169157465130500e-16,
+    1.640097681172717950e-16, 1.653075238380036909e-16,
+    1.666103007605742067e-16, 1.679182180938228863e-16,
+    1.692313964762022267e-16, 1.705499580496629830e-16,
+    1.718740265349031656e-16, 1.732037273081008369e-16,
+    1.745391874792533975e-16, 1.758805359722491379e-16,
+    1.772279036068006489e-16, 1.785814231823732619e-16,
+    1.799412295642463721e-16, 1.813074597718501559e-16,
+    1.826802530695252266e-16, 1.840597510598587828e-16,
+    1.854460977797569461e-16, 1.868394397994192684e-16,
+    1.882399263243892051e-16, 1.896477093008616722e-16,
+    1.910629435244376536e-16, 1.924857867525243818e-16,
+    1.939163998205899420e-16, 1.953549467624909132e-16,
+    1.968015949351037382e-16, 1.982565151475019047e-16,
+    1.997198817949342081e-16, 2.011918729978734671e-16,
+    2.026726707464198289e-16, 2.041624610503588774e-16,
+    2.056614340951917875e-16, 2.071697844044737034e-16,
+    2.086877110088159721e-16, 2.102154176219292789e-16,
+    2.117531128241075913e-16, 2.133010102535779087e-16,
+    2.148593288061663316e-16, 2.164282928437604723e-16,
+    2.180081324120784027e-16, 2.195990834682870728e-16,
+    2.212013881190495942e-16, 2.228152948696180545e-16,
+    2.244410588846308588e-16, 2.260789422613173739e-16,
+    2.277292143158621037e-16, 2.293921518837311354e-16,
+    2.310680396348213318e-16, 2.327571704043534613e-16,
+    2.344598455404957859e-16, 2.361763752697773994e-16,
+    2.379070790814276700e-16, 2.396522861318623520e-16,
+    2.414123356706293277e-16, 2.431875774892255956e-16,
+    2.449783723943070217e-16, 2.467850927069288738e-16,
+    2.486081227895851719e-16, 2.504478596029557040e-16,
+    2.523047132944217013e-16, 2.541791078205812227e-16,
+    2.560714816061770759e-16, 2.579822882420530896e-16,
+    2.599119972249746917e-16, 2.618610947423924219e-16,
+    2.638300845054942823e-16, 2.658194886341845120e-16,
+    2.678298485979525166e-16, 2.698617262169488933e-16,
+    2.719157047279818500e-16, 2.739923899205814823e-16,
+    2.760924113487617126e-16, 2.782164236246436081e-16,
+    2.803651078006983464e-16, 2.825391728480253184e-16,
+    2.847393572388174091e-16, 2.869664306419817679e-16,
+    2.892211957417995598e-16, 2.915044901905293183e-16,
+    2.938171887070028633e-16, 2.961602053345465687e-16,
+    2.985344958730045276e-16, 3.009410605012618141e-16,
+    3.033809466085003416e-16, 3.058552518544860874e-16,
+    3.083651274815310004e-16, 3.109117819034266344e-16,
+    3.134964845996663118e-16, 3.161205703467105734e-16,
+    3.187854438219713117e-16, 3.214925846206797361e-16,
+    3.242435527309451638e-16, 3.270399945182240440e-16,
+    3.298836492772283149e-16, 3.327763564171671408e-16,
+    3.357200633553244075e-16, 3.387168342045505162e-16,
+    3.417688593525636996e-16, 3.448784660453423890e-16,
+    3.480481301037442286e-16, 3.512804889222979418e-16,
+    3.545783559224791863e-16, 3.579447366604276541e-16,
+    3.613828468219060593e-16, 3.648961323764542545e-16,
+    3.684882922095621322e-16, 3.721633036080207290e-16,
+    3.759254510416256532e-16, 3.797793587668874387e-16,
+    3.837300278789213687e-16, 3.877828785607895292e-16,
+    3.919437984311428867e-16, 3.962191980786774996e-16,
+    4.006160751056541688e-16, 4.051420882956573177e-16,
+    4.098056438903062509e-16, 4.146159964290904582e-16,
+    4.195833672073398926e-16, 4.247190841824385048e-16,
+    4.300357481667470702e-16, 4.355474314693952008e-16,
+    4.412699169036069903e-16, 4.472209874259932285e-16,
+    4.534207798565834480e-16, 4.598922204905932469e-16,
+    4.666615664711475780e-16, 4.737590853262492027e-16,
+    4.812199172829237933e-16, 4.890851827392209900e-16,
+    4.974034236191939753e-16, 5.062325072144159699e-16,
+    5.156421828878082953e-16, 5.257175802022274839e-16,
+    5.365640977112021618e-16, 5.483144034258703912e-16,
+    5.611387454675159622e-16, 5.752606481503331688e-16,
+    5.909817641652102998e-16, 6.087231416180907671e-16,
+    6.290979034877557049e-16, 6.530492053564040799e-16,
+    6.821393079028928626e-16, 7.192444966089361564e-16,
+    7.706095350032096755e-16, 8.545517038584027421e-16};
+
+static const double fe_double[] = {
+    1.000000000000000000e+00, 9.381436808621747003e-01,
+    9.004699299257464817e-01, 8.717043323812035949e-01,
+    8.477855006239896074e-01, 8.269932966430503241e-01,
+    8.084216515230083777e-01, 7.915276369724956185e-01,
+    7.759568520401155522e-01, 7.614633888498962833e-01,
+    7.478686219851951034e-01, 7.350380924314234843e-01,
+    7.228676595935720206e-01, 7.112747608050760117e-01,
+    7.001926550827881623e-01, 6.895664961170779872e-01,
+    6.793505722647653622e-01, 6.695063167319247333e-01,
+    6.600008410789997004e-01, 6.508058334145710999e-01,
+    6.418967164272660897e-01, 6.332519942143660652e-01,
+    6.248527387036659775e-01, 6.166821809152076561e-01,
+    6.087253820796220127e-01, 6.009689663652322267e-01,
+    5.934009016917334289e-01, 5.860103184772680329e-01,
+    5.787873586028450257e-01, 5.717230486648258170e-01,
+    5.648091929124001709e-01, 5.580382822625874484e-01,
+    5.514034165406412891e-01, 5.448982376724396115e-01,
+    5.385168720028619127e-01, 5.322538802630433219e-01,
+    5.261042139836197284e-01, 5.200631773682335979e-01,
+    5.141263938147485613e-01, 5.082897764106428795e-01,
+    5.025495018413477233e-01, 4.969019872415495476e-01,
+    4.913438695940325340e-01, 4.858719873418849144e-01,
+    4.804833639304542103e-01, 4.751751930373773747e-01,
+    4.699448252839599771e-01, 4.647897562504261781e-01,
+    4.597076156421376902e-01, 4.546961574746155033e-01,
+    4.497532511627549967e-01, 4.448768734145485126e-01,
+    4.400651008423538957e-01, 4.353161032156365740e-01,
+    4.306281372884588343e-01, 4.259995411430343437e-01,
+    4.214287289976165751e-01, 4.169141864330028757e-01,
+    4.124544659971611793e-01, 4.080481831520323954e-01,
+    4.036940125305302773e-01, 3.993906844752310725e-01,
+    3.951369818332901573e-01, 3.909317369847971069e-01,
+    3.867738290841376547e-01, 3.826621814960098344e-01,
+    3.785957594095807899e-01, 3.745735676159021588e-01,
+    3.705946484351460013e-01, 3.666580797815141568e-01,
+    3.627629733548177748e-01, 3.589084729487497794e-01,
+    3.550937528667874599e-01, 3.513180164374833381e-01,
+    3.475804946216369817e-01, 3.438804447045024082e-01,
+    3.402171490667800224e-01, 3.365899140286776059e-01,
+    3.329980687618089852e-01, 3.294409642641363267e-01,
+    3.259179723935561879e-01, 3.224284849560891675e-01,
+    3.189719128449572394e-01, 3.155476852271289490e-01,
+    3.121552487741795501e-01, 3.087940669345601852e-01,
+    3.054636192445902565e-01, 3.021634006756935276e-01,
+    2.988929210155817917e-01, 2.956517042812611962e-01,
+    2.924392881618925744e-01, 2.892552234896777485e-01,
+    2.860990737370768255e-01, 2.829704145387807457e-01,
+    2.798688332369729248e-01, 2.767939284485173568e-01,
+    2.737453096528029706e-01, 2.707225967990600224e-01,
+    2.677254199320447947e-01, 2.647534188350622042e-01,
+    2.618062426893629779e-01, 2.588835497490162285e-01,
+    2.559850070304153791e-01, 2.531102900156294577e-01,
+    2.502590823688622956e-01, 2.474310756653276266e-01,
+    2.446259691318921070e-01, 2.418434693988772144e-01,
+    2.390832902624491774e-01, 2.363451524570596429e-01,
+    2.336287834374333461e-01, 2.309339171696274118e-01,
+    2.282602939307167011e-01, 2.256076601166840667e-01,
+    2.229757680581201940e-01, 2.203643758433594946e-01,
+    2.177732471487005272e-01, 2.152021510753786837e-01,
+    2.126508619929782795e-01, 2.101191593889882581e-01,
+    2.076068277242220372e-01, 2.051136562938377095e-01,
+    2.026394390937090173e-01, 2.001839746919112650e-01,
+    1.977470661050988732e-01, 1.953285206795632167e-01,
+    1.929281499767713515e-01, 1.905457696631953912e-01,
+    1.881811994042543179e-01, 1.858342627621971110e-01,
+    1.835047870977674633e-01, 1.811926034754962889e-01,
+    1.788975465724783054e-01, 1.766194545904948843e-01,
+    1.743581691713534942e-01, 1.721135353153200598e-01,
+    1.698854013025276610e-01, 1.676736186172501919e-01,
+    1.654780418749360049e-01, 1.632985287519018169e-01,
+    1.611349399175920349e-01, 1.589871389693142123e-01,
+    1.568549923693652315e-01, 1.547383693844680830e-01,
+    1.526371420274428570e-01, 1.505511850010398944e-01,
+    1.484803756438667910e-01, 1.464245938783449441e-01,
+    1.443837221606347754e-01, 1.423576454324722018e-01,
+    1.403462510748624548e-01, 1.383494288635802039e-01,
+    1.363670709264288572e-01, 1.343990717022136294e-01,
+    1.324453279013875218e-01, 1.305057384683307731e-01,
+    1.285802045452281717e-01, 1.266686294375106714e-01,
+    1.247709185808309612e-01, 1.228869795095451356e-01,
+    1.210167218266748335e-01, 1.191600571753276827e-01,
+    1.173168992115555670e-01, 1.154871635786335338e-01,
+    1.136707678827443141e-01, 1.118676316700562973e-01,
+    1.100776764051853845e-01, 1.083008254510337970e-01,
+    1.065370040500016602e-01, 1.047861393065701724e-01,
+    1.030481601712577161e-01, 1.013229974259536315e-01,
+    9.961058367063713170e-02, 9.791085331149219917e-02,
+    9.622374255043279756e-02, 9.454918937605585882e-02,
+    9.288713355604354127e-02, 9.123751663104015530e-02,
+    8.960028191003285847e-02, 8.797537446727021759e-02,
+    8.636274114075691288e-02, 8.476233053236811865e-02,
+    8.317409300963238272e-02, 8.159798070923741931e-02,
+    8.003394754231990538e-02, 7.848194920160642130e-02,
+    7.694194317048050347e-02, 7.541388873405840965e-02,
+    7.389774699236474620e-02, 7.239348087570873780e-02,
+    7.090105516237182881e-02, 6.942043649872875477e-02,
+    6.795159342193660135e-02, 6.649449638533977414e-02,
+    6.504911778675374900e-02, 6.361543199980733421e-02,
+    6.219341540854099459e-02, 6.078304644547963265e-02,
+    5.938430563342026597e-02, 5.799717563120065922e-02,
+    5.662164128374287675e-02, 5.525768967669703741e-02,
+    5.390531019604608703e-02, 5.256449459307169225e-02,
+    5.123523705512628146e-02, 4.991753428270637172e-02,
+    4.861138557337949667e-02, 4.731679291318154762e-02,
+    4.603376107617516977e-02, 4.476229773294328196e-02,
+    4.350241356888818328e-02, 4.225412241331623353e-02,
+    4.101744138041481941e-02, 3.979239102337412542e-02,
+    3.857899550307485742e-02, 3.737728277295936097e-02,
+    3.618728478193142251e-02, 3.500903769739741045e-02,
+    3.384258215087432992e-02, 3.268796350895953468e-02,
+    3.154523217289360859e-02, 3.041444391046660423e-02,
+    2.929566022463739317e-02, 2.818894876397863569e-02,
+    2.709438378095579969e-02, 2.601204664513421735e-02,
+    2.494202641973178314e-02, 2.388442051155817078e-02,
+    2.283933540638524023e-02, 2.180688750428358066e-02,
+    2.078720407257811723e-02, 1.978042433800974303e-02,
+    1.878670074469603046e-02, 1.780620041091136169e-02,
+    1.683910682603994777e-02, 1.588562183997316302e-02,
+    1.494596801169114850e-02, 1.402039140318193759e-02,
+    1.310916493125499106e-02, 1.221259242625538123e-02,
+    1.133101359783459695e-02, 1.046481018102997894e-02,
+    9.614413642502209895e-03, 8.780314985808975251e-03,
+    7.963077438017040002e-03, 7.163353183634983863e-03,
+    6.381905937319179087e-03, 5.619642207205483020e-03,
+    4.877655983542392333e-03, 4.157295120833795314e-03,
+    3.460264777836904049e-03, 2.788798793574076128e-03,
+    2.145967743718906265e-03, 1.536299780301572356e-03,
+    9.672692823271745359e-04, 4.541343538414967652e-04};
+
+static const uint32_t ke_float[] = {
+    0x00714851UL, 0x00000000UL, 0x004DF56FUL, 0x0061BBD6UL, 0x006A6EDDUL,
+    0x006F44A0UL, 0x00725474UL, 0x00746FF9UL, 0x0075F96FUL, 0x007724D3UL,
+    0x00781027UL, 0x0078CDEEUL, 0x00796A2CUL, 0x0079ED08UL, 0x007A5C37UL,
+    0x007ABBD7UL, 0x007B0EF4UL, 0x007B57DCUL, 0x007B9853UL, 0x007BD1BBUL,
+    0x007C052EUL, 0x007C338CUL, 0x007C5D8EUL, 0x007C83C8UL, 0x007CA6B8UL,
+    0x007CC6C6UL, 0x007CE449UL, 0x007CFF8CUL, 0x007D18CDUL, 0x007D3043UL,
+    0x007D461DUL, 0x007D5A84UL, 0x007D6D9BUL, 0x007D7F82UL, 0x007D9053UL,
+    0x007DA028UL, 0x007DAF15UL, 0x007DBD2DUL, 0x007DCA82UL, 0x007DD722UL,
+    0x007DE31CUL, 0x007DEE7CUL, 0x007DF94DUL, 0x007E0399UL, 0x007E0D69UL,
+    0x007E16C6UL, 0x007E1FB6UL, 0x007E2842UL, 0x007E306FUL, 0x007E3843UL,
+    0x007E3FC4UL, 0x007E46F6UL, 0x007E4DDFUL, 0x007E5481UL, 0x007E5AE2UL,
+    0x007E6104UL, 0x007E66ECUL, 0x007E6C9BUL, 0x007E7215UL, 0x007E775DUL,
+    0x007E7C76UL, 0x007E8160UL, 0x007E8620UL, 0x007E8AB6UL, 0x007E8F24UL,
+    0x007E936DUL, 0x007E9793UL, 0x007E9B95UL, 0x007E9F77UL, 0x007EA33AUL,
+    0x007EA6DEUL, 0x007EAA66UL, 0x007EADD1UL, 0x007EB123UL, 0x007EB45AUL,
+    0x007EB779UL, 0x007EBA80UL, 0x007EBD71UL, 0x007EC04BUL, 0x007EC310UL,
+    0x007EC5C1UL, 0x007EC85EUL, 0x007ECAE9UL, 0x007ECD61UL, 0x007ECFC7UL,
+    0x007ED21CUL, 0x007ED460UL, 0x007ED694UL, 0x007ED8B9UL, 0x007EDACEUL,
+    0x007EDCD5UL, 0x007EDECEUL, 0x007EE0B8UL, 0x007EE296UL, 0x007EE466UL,
+    0x007EE62AUL, 0x007EE7E2UL, 0x007EE98DUL, 0x007EEB2DUL, 0x007EECC1UL,
+    0x007EEE4AUL, 0x007EEFC9UL, 0x007EF13DUL, 0x007EF2A7UL, 0x007EF406UL,
+    0x007EF55CUL, 0x007EF6A8UL, 0x007EF7EBUL, 0x007EF924UL, 0x007EFA55UL,
+    0x007EFB7DUL, 0x007EFC9CUL, 0x007EFDB2UL, 0x007EFEC1UL, 0x007EFFC7UL,
+    0x007F00C5UL, 0x007F01BBUL, 0x007F02AAUL, 0x007F0391UL, 0x007F0470UL,
+    0x007F0548UL, 0x007F0618UL, 0x007F06E2UL, 0x007F07A4UL, 0x007F0860UL,
+    0x007F0914UL, 0x007F09C2UL, 0x007F0A69UL, 0x007F0B09UL, 0x007F0BA3UL,
+    0x007F0C36UL, 0x007F0CC2UL, 0x007F0D48UL, 0x007F0DC8UL, 0x007F0E41UL,
+    0x007F0EB4UL, 0x007F0F21UL, 0x007F0F88UL, 0x007F0FE8UL, 0x007F1042UL,
+    0x007F1096UL, 0x007F10E4UL, 0x007F112BUL, 0x007F116DUL, 0x007F11A8UL,
+    0x007F11DDUL, 0x007F120CUL, 0x007F1235UL, 0x007F1258UL, 0x007F1274UL,
+    0x007F128AUL, 0x007F129AUL, 0x007F12A4UL, 0x007F12A7UL, 0x007F12A4UL,
+    0x007F129BUL, 0x007F128BUL, 0x007F1274UL, 0x007F1257UL, 0x007F1233UL,
+    0x007F1209UL, 0x007F11D8UL, 0x007F119FUL, 0x007F1160UL, 0x007F111AUL,
+    0x007F10CCUL, 0x007F1077UL, 0x007F101BUL, 0x007F0FB7UL, 0x007F0F4BUL,
+    0x007F0ED7UL, 0x007F0E5CUL, 0x007F0DD8UL, 0x007F0D4CUL, 0x007F0CB7UL,
+    0x007F0C19UL, 0x007F0B73UL, 0x007F0AC3UL, 0x007F0A0AUL, 0x007F0947UL,
+    0x007F087BUL, 0x007F07A4UL, 0x007F06C2UL, 0x007F05D6UL, 0x007F04DFUL,
+    0x007F03DCUL, 0x007F02CDUL, 0x007F01B2UL, 0x007F008BUL, 0x007EFF56UL,
+    0x007EFE13UL, 0x007EFCC3UL, 0x007EFB64UL, 0x007EF9F6UL, 0x007EF878UL,
+    0x007EF6EAUL, 0x007EF54BUL, 0x007EF39AUL, 0x007EF1D6UL, 0x007EEFFFUL,
+    0x007EEE14UL, 0x007EEC13UL, 0x007EE9FDUL, 0x007EE7CFUL, 0x007EE589UL,
+    0x007EE329UL, 0x007EE0AEUL, 0x007EDE16UL, 0x007EDB61UL, 0x007ED88CUL,
+    0x007ED595UL, 0x007ED27BUL, 0x007ECF3BUL, 0x007ECBD3UL, 0x007EC841UL,
+    0x007EC481UL, 0x007EC091UL, 0x007EBC6DUL, 0x007EB811UL, 0x007EB37AUL,
+    0x007EAEA4UL, 0x007EA988UL, 0x007EA422UL, 0x007E9E6BUL, 0x007E985DUL,
+    0x007E91EFUL, 0x007E8B1AUL, 0x007E83D4UL, 0x007E7C11UL, 0x007E73C5UL,
+    0x007E6AE1UL, 0x007E6155UL, 0x007E570FUL, 0x007E4BF7UL, 0x007E3FF3UL,
+    0x007E32E6UL, 0x007E24ACUL, 0x007E1518UL, 0x007E03F7UL, 0x007DF10AUL,
+    0x007DDC03UL, 0x007DC480UL, 0x007DAA09UL, 0x007D8C00UL, 0x007D699AUL,
+    0x007D41C9UL, 0x007D131EUL, 0x007CDB97UL, 0x007C9851UL, 0x007C44F8UL,
+    0x007BDABCUL, 0x007B4E33UL, 0x007A8A98UL, 0x00796587UL, 0x007777D9UL,
+    0x00736D37UL,
+};
+static const float we_float[] = {
+    1.03677719e-06F, 7.61177108e-09F, 1.24977240e-08F, 1.63680292e-08F,
+    1.96847466e-08F, 2.26448404e-08F, 2.53524197e-08F, 2.78699974e-08F,
+    3.02384333e-08F, 3.24861032e-08F, 3.46336312e-08F, 3.66965478e-08F,
+    3.86868855e-08F, 4.06141855e-08F, 4.24861622e-08F, 4.43091566e-08F,
+    4.60884545e-08F, 4.78285168e-08F, 4.95331490e-08F, 5.12056279e-08F,
+    5.28488000e-08F, 5.44651557e-08F, 5.60568899e-08F, 5.76259484e-08F,
+    5.91740662e-08F, 6.07027987e-08F, 6.22135462e-08F, 6.37075759e-08F,
+    6.51860386e-08F, 6.66499836e-08F, 6.81003709e-08F, 6.95380822e-08F,
+    7.09639292e-08F, 7.23786618e-08F, 7.37829746e-08F, 7.51775128e-08F,
+    7.65628768e-08F, 7.79396272e-08F, 7.93082883e-08F, 8.06693516e-08F,
+    8.20232788e-08F, 8.33705045e-08F, 8.47114385e-08F, 8.60464681e-08F,
+    8.73759596e-08F, 8.87002606e-08F, 9.00197010e-08F, 9.13345948e-08F,
+    9.26452410e-08F, 9.39519249e-08F, 9.52549192e-08F, 9.65544849e-08F,
+    9.78508719e-08F, 9.91443202e-08F, 1.00435060e-07F, 1.01723315e-07F,
+    1.03009296e-07F, 1.04293211e-07F, 1.05575259e-07F, 1.06855633e-07F,
+    1.08134518e-07F, 1.09412096e-07F, 1.10688542e-07F, 1.11964025e-07F,
+    1.13238713e-07F, 1.14512767e-07F, 1.15786343e-07F, 1.17059595e-07F,
+    1.18332673e-07F, 1.19605723e-07F, 1.20878890e-07F, 1.22152313e-07F,
+    1.23426131e-07F, 1.24700479e-07F, 1.25975490e-07F, 1.27251294e-07F,
+    1.28528022e-07F, 1.29805799e-07F, 1.31084751e-07F, 1.32365001e-07F,
+    1.33646673e-07F, 1.34929886e-07F, 1.36214760e-07F, 1.37501415e-07F,
+    1.38789966e-07F, 1.40080532e-07F, 1.41373228e-07F, 1.42668169e-07F,
+    1.43965470e-07F, 1.45265245e-07F, 1.46567606e-07F, 1.47872669e-07F,
+    1.49180545e-07F, 1.50491348e-07F, 1.51805191e-07F, 1.53122186e-07F,
+    1.54442445e-07F, 1.55766083e-07F, 1.57093212e-07F, 1.58423946e-07F,
+    1.59758399e-07F, 1.61096684e-07F, 1.62438917e-07F, 1.63785214e-07F,
+    1.65135690e-07F, 1.66490462e-07F, 1.67849647e-07F, 1.69213364e-07F,
+    1.70581733e-07F, 1.71954874e-07F, 1.73332908e-07F, 1.74715958e-07F,
+    1.76104148e-07F, 1.77497602e-07F, 1.78896448e-07F, 1.80300814e-07F,
+    1.81710828e-07F, 1.83126623e-07F, 1.84548331e-07F, 1.85976086e-07F,
+    1.87410026e-07F, 1.88850288e-07F, 1.90297012e-07F, 1.91750343e-07F,
+    1.93210424e-07F, 1.94677403e-07F, 1.96151428e-07F, 1.97632653e-07F,
+    1.99121231e-07F, 2.00617321e-07F, 2.02121082e-07F, 2.03632677e-07F,
+    2.05152273e-07F, 2.06680040e-07F, 2.08216149e-07F, 2.09760777e-07F,
+    2.11314104e-07F, 2.12876312e-07F, 2.14447590e-07F, 2.16028129e-07F,
+    2.17618123e-07F, 2.19217773e-07F, 2.20827283e-07F, 2.22446862e-07F,
+    2.24076723e-07F, 2.25717086e-07F, 2.27368174e-07F, 2.29030216e-07F,
+    2.30703448e-07F, 2.32388110e-07F, 2.34084450e-07F, 2.35792720e-07F,
+    2.37513182e-07F, 2.39246101e-07F, 2.40991752e-07F, 2.42750416e-07F,
+    2.44522382e-07F, 2.46307948e-07F, 2.48107418e-07F, 2.49921109e-07F,
+    2.51749342e-07F, 2.53592452e-07F, 2.55450781e-07F, 2.57324683e-07F,
+    2.59214522e-07F, 2.61120673e-07F, 2.63043524e-07F, 2.64983476e-07F,
+    2.66940939e-07F, 2.68916342e-07F, 2.70910123e-07F, 2.72922739e-07F,
+    2.74954660e-07F, 2.77006373e-07F, 2.79078382e-07F, 2.81171210e-07F,
+    2.83285396e-07F, 2.85421503e-07F, 2.87580110e-07F, 2.89761822e-07F,
+    2.91967265e-07F, 2.94197089e-07F, 2.96451969e-07F, 2.98732610e-07F,
+    3.01039742e-07F, 3.03374127e-07F, 3.05736557e-07F, 3.08127859e-07F,
+    3.10548894e-07F, 3.13000563e-07F, 3.15483804e-07F, 3.17999599e-07F,
+    3.20548974e-07F, 3.23133003e-07F, 3.25752811e-07F, 3.28409576e-07F,
+    3.31104534e-07F, 3.33838984e-07F, 3.36614287e-07F, 3.39431878e-07F,
+    3.42293264e-07F, 3.45200034e-07F, 3.48153864e-07F, 3.51156520e-07F,
+    3.54209871e-07F, 3.57315892e-07F, 3.60476673e-07F, 3.63694431e-07F,
+    3.66971518e-07F, 3.70310433e-07F, 3.73713834e-07F, 3.77184553e-07F,
+    3.80725611e-07F, 3.84340234e-07F, 3.88031877e-07F, 3.91804239e-07F,
+    3.95661291e-07F, 3.99607304e-07F, 4.03646879e-07F, 4.07784981e-07F,
+    4.12026980e-07F, 4.16378695e-07F, 4.20846449e-07F, 4.25437124e-07F,
+    4.30158235e-07F, 4.35018005e-07F, 4.40025460e-07F, 4.45190536e-07F,
+    4.50524210e-07F, 4.56038644e-07F, 4.61747369e-07F, 4.67665494e-07F,
+    4.73809965e-07F, 4.80199879e-07F, 4.86856855e-07F, 4.93805512e-07F,
+    5.01074042e-07F, 5.08694944e-07F, 5.16705952e-07F, 5.25151216e-07F,
+    5.34082859e-07F, 5.43563016e-07F, 5.53666578e-07F, 5.64484953e-07F,
+    5.76131313e-07F, 5.88748108e-07F, 6.02518140e-07F, 6.17681418e-07F,
+    6.34561837e-07F, 6.53611496e-07F, 6.75488730e-07F, 7.01206245e-07F,
+    7.32441505e-07F, 7.72282898e-07F, 8.27435688e-07F, 9.17567905e-07F,
+};
+static const float fe_float[] = {
+    1.00000000e+00F, 9.38143681e-01F, 9.00469930e-01F, 8.71704332e-01F,
+    8.47785501e-01F, 8.26993297e-01F, 8.08421652e-01F, 7.91527637e-01F,
+    7.75956852e-01F, 7.61463389e-01F, 7.47868622e-01F, 7.35038092e-01F,
+    7.22867660e-01F, 7.11274761e-01F, 7.00192655e-01F, 6.89566496e-01F,
+    6.79350572e-01F, 6.69506317e-01F, 6.60000841e-01F, 6.50805833e-01F,
+    6.41896716e-01F, 6.33251994e-01F, 6.24852739e-01F, 6.16682181e-01F,
+    6.08725382e-01F, 6.00968966e-01F, 5.93400902e-01F, 5.86010318e-01F,
+    5.78787359e-01F, 5.71723049e-01F, 5.64809193e-01F, 5.58038282e-01F,
+    5.51403417e-01F, 5.44898238e-01F, 5.38516872e-01F, 5.32253880e-01F,
+    5.26104214e-01F, 5.20063177e-01F, 5.14126394e-01F, 5.08289776e-01F,
+    5.02549502e-01F, 4.96901987e-01F, 4.91343870e-01F, 4.85871987e-01F,
+    4.80483364e-01F, 4.75175193e-01F, 4.69944825e-01F, 4.64789756e-01F,
+    4.59707616e-01F, 4.54696157e-01F, 4.49753251e-01F, 4.44876873e-01F,
+    4.40065101e-01F, 4.35316103e-01F, 4.30628137e-01F, 4.25999541e-01F,
+    4.21428729e-01F, 4.16914186e-01F, 4.12454466e-01F, 4.08048183e-01F,
+    4.03694013e-01F, 3.99390684e-01F, 3.95136982e-01F, 3.90931737e-01F,
+    3.86773829e-01F, 3.82662181e-01F, 3.78595759e-01F, 3.74573568e-01F,
+    3.70594648e-01F, 3.66658080e-01F, 3.62762973e-01F, 3.58908473e-01F,
+    3.55093753e-01F, 3.51318016e-01F, 3.47580495e-01F, 3.43880445e-01F,
+    3.40217149e-01F, 3.36589914e-01F, 3.32998069e-01F, 3.29440964e-01F,
+    3.25917972e-01F, 3.22428485e-01F, 3.18971913e-01F, 3.15547685e-01F,
+    3.12155249e-01F, 3.08794067e-01F, 3.05463619e-01F, 3.02163401e-01F,
+    2.98892921e-01F, 2.95651704e-01F, 2.92439288e-01F, 2.89255223e-01F,
+    2.86099074e-01F, 2.82970415e-01F, 2.79868833e-01F, 2.76793928e-01F,
+    2.73745310e-01F, 2.70722597e-01F, 2.67725420e-01F, 2.64753419e-01F,
+    2.61806243e-01F, 2.58883550e-01F, 2.55985007e-01F, 2.53110290e-01F,
+    2.50259082e-01F, 2.47431076e-01F, 2.44625969e-01F, 2.41843469e-01F,
+    2.39083290e-01F, 2.36345152e-01F, 2.33628783e-01F, 2.30933917e-01F,
+    2.28260294e-01F, 2.25607660e-01F, 2.22975768e-01F, 2.20364376e-01F,
+    2.17773247e-01F, 2.15202151e-01F, 2.12650862e-01F, 2.10119159e-01F,
+    2.07606828e-01F, 2.05113656e-01F, 2.02639439e-01F, 2.00183975e-01F,
+    1.97747066e-01F, 1.95328521e-01F, 1.92928150e-01F, 1.90545770e-01F,
+    1.88181199e-01F, 1.85834263e-01F, 1.83504787e-01F, 1.81192603e-01F,
+    1.78897547e-01F, 1.76619455e-01F, 1.74358169e-01F, 1.72113535e-01F,
+    1.69885401e-01F, 1.67673619e-01F, 1.65478042e-01F, 1.63298529e-01F,
+    1.61134940e-01F, 1.58987139e-01F, 1.56854992e-01F, 1.54738369e-01F,
+    1.52637142e-01F, 1.50551185e-01F, 1.48480376e-01F, 1.46424594e-01F,
+    1.44383722e-01F, 1.42357645e-01F, 1.40346251e-01F, 1.38349429e-01F,
+    1.36367071e-01F, 1.34399072e-01F, 1.32445328e-01F, 1.30505738e-01F,
+    1.28580205e-01F, 1.26668629e-01F, 1.24770919e-01F, 1.22886980e-01F,
+    1.21016722e-01F, 1.19160057e-01F, 1.17316899e-01F, 1.15487164e-01F,
+    1.13670768e-01F, 1.11867632e-01F, 1.10077676e-01F, 1.08300825e-01F,
+    1.06537004e-01F, 1.04786139e-01F, 1.03048160e-01F, 1.01322997e-01F,
+    9.96105837e-02F, 9.79108533e-02F, 9.62237426e-02F, 9.45491894e-02F,
+    9.28871336e-02F, 9.12375166e-02F, 8.96002819e-02F, 8.79753745e-02F,
+    8.63627411e-02F, 8.47623305e-02F, 8.31740930e-02F, 8.15979807e-02F,
+    8.00339475e-02F, 7.84819492e-02F, 7.69419432e-02F, 7.54138887e-02F,
+    7.38977470e-02F, 7.23934809e-02F, 7.09010552e-02F, 6.94204365e-02F,
+    6.79515934e-02F, 6.64944964e-02F, 6.50491178e-02F, 6.36154320e-02F,
+    6.21934154e-02F, 6.07830464e-02F, 5.93843056e-02F, 5.79971756e-02F,
+    5.66216413e-02F, 5.52576897e-02F, 5.39053102e-02F, 5.25644946e-02F,
+    5.12352371e-02F, 4.99175343e-02F, 4.86113856e-02F, 4.73167929e-02F,
+    4.60337611e-02F, 4.47622977e-02F, 4.35024136e-02F, 4.22541224e-02F,
+    4.10174414e-02F, 3.97923910e-02F, 3.85789955e-02F, 3.73772828e-02F,
+    3.61872848e-02F, 3.50090377e-02F, 3.38425822e-02F, 3.26879635e-02F,
+    3.15452322e-02F, 3.04144439e-02F, 2.92956602e-02F, 2.81889488e-02F,
+    2.70943838e-02F, 2.60120466e-02F, 2.49420264e-02F, 2.38844205e-02F,
+    2.28393354e-02F, 2.18068875e-02F, 2.07872041e-02F, 1.97804243e-02F,
+    1.87867007e-02F, 1.78062004e-02F, 1.68391068e-02F, 1.58856218e-02F,
+    1.49459680e-02F, 1.40203914e-02F, 1.31091649e-02F, 1.22125924e-02F,
+    1.13310136e-02F, 1.04648102e-02F, 9.61441364e-03F, 8.78031499e-03F,
+    7.96307744e-03F, 7.16335318e-03F, 6.38190594e-03F, 5.61964221e-03F,
+    4.87765598e-03F, 4.15729512e-03F, 3.46026478e-03F, 2.78879879e-03F,
+    2.14596774e-03F, 1.53629978e-03F, 9.67269282e-04F, 4.54134354e-04F,
+};
diff --git a/numpy/random/src/dsfmt/128-bit-jump.poly.txt b/numpy/random/src/dsfmt/128-bit-jump.poly.txt
new file mode 100644
index 000000000..fea1318fb
--- /dev/null
+++ b/numpy/random/src/dsfmt/128-bit-jump.poly.txt
@@ -0,0 +1,2 @@
+jump polynomial:
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
diff --git a/numpy/random/src/dsfmt/96-bit-jump.poly.txt b/numpy/random/src/dsfmt/96-bit-jump.poly.txt
new file mode 100644
index 000000000..15c68d155
--- /dev/null
+++ b/numpy/random/src/dsfmt/96-bit-jump.poly.txt
@@ -0,0 +1,2 @@
+jump polynomial:
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
diff --git a/numpy/random/src/dsfmt/LICENSE.md b/numpy/random/src/dsfmt/LICENSE.md
new file mode 100644
index 000000000..d59568f6b
--- /dev/null
+++ b/numpy/random/src/dsfmt/LICENSE.md
@@ -0,0 +1,34 @@
+# DSFMT
+
+Copyright (c) 2007, 2008, 2009 Mutsuo Saito, Makoto Matsumoto
+and Hiroshima University.
+Copyright (c) 2011, 2002 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+University and The University of Tokyo.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided
+  with the distribution.
+* Neither the name of the Hiroshima University nor the names of
+  its contributors may be used to endorse or promote products
+  derived from this software without specific prior written
+  permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/numpy/random/src/dsfmt/calc-jump.cpp b/numpy/random/src/dsfmt/calc-jump.cpp
new file mode 100644
index 000000000..495b2797c
--- /dev/null
+++ b/numpy/random/src/dsfmt/calc-jump.cpp
@@ -0,0 +1,81 @@
+/**
+ * @file calc-jump.cpp
+ *
+ * @brief calc jump function.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (The University of Tokyo)
+ *
+ * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto,
+ * Hiroshima University and The University of Tokyo.
+ * All rights reserved.
+ *
+ * The 3-clause BSD License is applied to this software, see
+ * LICENSE.txt
+ *
+ * Compile:
+ * g++ calc-jump.cpp -o calc-jump -lntl
+ *
+ * Compute polynomial for 2^128 steps:
+ * ./calc-jump 340282366920938463463374607431768211456 poly.19937.txt
+ *
+ */
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <inttypes.h>
+#include <stdint.h>
+#include <time.h>
+#include <NTL/GF2X.h>
+#include <NTL/vec_GF2.h>
+#include <NTL/ZZ.h>
+#include "dSFMT-calc-jump.hpp"
+
+using namespace NTL;
+using namespace std;
+using namespace dsfmt;
+
+static void read_file(GF2X& lcmpoly, long line_no, const string& file);
+
+int main(int argc, char * argv[]) {
+    if (argc <= 2) {
+	cout << argv[0] << " jump-step poly-file" << endl;
+	cout << "    jump-step: a number between zero and 2^{DSFMT_MEXP}-1.\n"
+	     << "               large decimal number is allowed." << endl;
+	cout << "    poly-file: one of poly.{MEXP}.txt "
+	     << "file" << endl;
+	return -1;
+    }
+    string step_string = argv[1];
+    string filename = argv[2];
+    long no = 0;
+    GF2X lcmpoly;
+    read_file(lcmpoly, no, filename);
+    ZZ step;
+    stringstream ss(step_string);
+    ss >> step;
+    string jump_str;
+    calc_jump(jump_str, step, lcmpoly);
+    cout << "jump polynomial:" << endl;
+    cout << jump_str << endl;
+    return 0;
+}
+
+
+static void read_file(GF2X& lcmpoly, long line_no, const string& file)
+{
+    ifstream ifs(file.c_str());
+    string line;
+    for (int i = 0; i < line_no; i++) {
+	ifs >> line;
+	ifs >> line;
+    }
+    if (ifs) {
+	ifs >> line;
+	line = "";
+	ifs >> line;
+    }
+    stringtopoly(lcmpoly, line);
+}
diff --git a/numpy/random/src/dsfmt/dSFMT-benchmark.c b/numpy/random/src/dsfmt/dSFMT-benchmark.c
new file mode 100644
index 000000000..af29d0e1f
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-benchmark.c
@@ -0,0 +1,43 @@
+/*
+ *
+ * cl dsfmt-benchmark.c dSFMT.c /Ox -DHAVE_SSE2
+ *
+ * gcc dSFMT-benchmark.c dSFMT.c -O3 -DHAVE_SSE2 -DDSFMT_MEXP=19937 -o
+ * dSFMT-benchmark
+ */
+#include <inttypes.h>
+#include <time.h>
+
+#include "dSFMT.h"
+
+
+#define N 1000000000
+
+int main() {
+  int i, j;
+  uint32_t seed = 0xDEADBEAF;
+  uint64_t count = 0, sum = 0;
+  dsfmt_t state;
+  double buffer[DSFMT_N64];
+
+  uint64_t out;
+  uint64_t *tmp;
+  dsfmt_init_gen_rand(&state, seed);
+  clock_t begin = clock();
+  for (i = 0; i < N / (DSFMT_N64 / 2); i++) {
+    dsfmt_fill_array_close_open(&state, &buffer[0], DSFMT_N64);
+    for (j = 0; j < DSFMT_N64; j += 2) {
+      tmp = (uint64_t *)&buffer[j];
+      out = (*tmp >> 16) << 32;
+      tmp = (uint64_t *)&buffer[j + 1];
+      out |= (*tmp >> 16) & 0xffffffff;
+      sum += out;
+      count++;
+    }
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(N / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/dsfmt/dSFMT-calc-jump.hpp b/numpy/random/src/dsfmt/dSFMT-calc-jump.hpp
new file mode 100644
index 000000000..b960826be
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-calc-jump.hpp
@@ -0,0 +1,106 @@
+#pragma once
+#ifndef DSFMT_CALC_JUMP_HPP
+#define DSFMT_CALC_JUMP_HPP
+/**
+ * @file dSFMT-calc-jump.hpp
+ *
+ * @brief functions for calculating jump polynomial.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (The University of Tokyo)
+ *
+ * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto,
+ * Hiroshima University and The University of Tokyo.
+ * All rights reserved.
+ *
+ * The 3-clause BSD License is applied to this software, see
+ * LICENSE.txt
+ */
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <NTL/GF2X.h>
+
+namespace dsfmt {
+/**
+ * converts polynomial to string for convenient use in C language.
+ * @param x output string
+ * @param polynomial input polynomial
+ */
+    static inline void polytostring(std::string& x, NTL::GF2X& polynomial)
+    {
+	using namespace NTL;
+	using namespace std;
+
+	long degree = deg(polynomial);
+	int buff;
+	stringstream ss;
+	for (int i = 0; i <= degree; i+=4) {
+	    buff = 0;
+	    for (int j = 0; j < 4; j++) {
+		if (IsOne(coeff(polynomial, i + j))) {
+		    buff |= 1 << j;
+		} else {
+		    buff &= (0x0f ^ (1 << j));
+		}
+	    }
+	    ss << hex << buff;
+	}
+	ss << flush;
+	x = ss.str();
+    }
+
+/**
+ * converts string to polynomial
+ * @param str string
+ * @param poly output polynomial
+ */
+    static inline void stringtopoly(NTL::GF2X& poly, std::string& str)
+    {
+	using namespace NTL;
+	using namespace std;
+
+	stringstream ss(str);
+	char c;
+	long p = 0;
+	clear(poly);
+	while(ss) {
+	    ss >> c;
+	    if (!ss) {
+		break;
+	    }
+	    if (c >= 'a') {
+		c = c - 'a' + 10;
+	    } else {
+		c = c - '0';
+	    }
+	    for (int j = 0; j < 4; j++) {
+		if (c & (1 << j)) {
+		    SetCoeff(poly, p, 1);
+		} else {
+		    SetCoeff(poly, p, 0);
+		}
+		p++;
+	    }
+	}
+    }
+
+/**
+ * calculate the jump polynomial.
+ * SFMT generates 4 32-bit integers from one internal state.
+ * @param jump_str output string which represents jump polynomial.
+ * @param step jump step of internal state
+ * @param characteristic polynomial
+ */
+    static inline void calc_jump(std::string& jump_str,
+				 NTL::ZZ& step,
+				 NTL::GF2X& characteristic)
+    {
+	using namespace NTL;
+	using namespace std;
+	GF2X jump;
+	PowerXMod(jump, step, characteristic);
+	polytostring(jump_str, jump);
+    }
+}
+#endif
diff --git a/numpy/random/src/dsfmt/dSFMT-common.h b/numpy/random/src/dsfmt/dSFMT-common.h
new file mode 100644
index 000000000..30c26c08b
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-common.h
@@ -0,0 +1,115 @@
+#pragma once
+/**
+ * @file dSFMT-common.h
+ *
+ * @brief SIMD oriented Fast Mersenne Twister(SFMT) pseudorandom
+ * number generator with jump function. This file includes common functions
+ * used in random number generation and jump.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (The University of Tokyo)
+ *
+ * Copyright (C) 2006, 2007 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+ * University.
+ * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+ * University and The University of Tokyo.
+ * All rights reserved.
+ *
+ * The 3-clause BSD License is applied to this software, see
+ * LICENSE.txt
+ */
+#ifndef DSFMT_COMMON_H
+#define DSFMT_COMMON_H
+
+#include "dSFMT.h"
+
+#if defined(HAVE_SSE2)
+#  include <emmintrin.h>
+union X128I_T {
+    uint64_t u[2];
+    __m128i  i128;
+};
+union X128D_T {
+    double d[2];
+    __m128d d128;
+};
+/** mask data for sse2 */
+static const union X128I_T sse2_param_mask = {{DSFMT_MSK1, DSFMT_MSK2}};
+#endif
+
+#if defined(HAVE_ALTIVEC)
+inline static void do_recursion(w128_t *r, w128_t *a, w128_t * b,
+				w128_t *lung) {
+    const vector unsigned char sl1 = ALTI_SL1;
+    const vector unsigned char sl1_perm = ALTI_SL1_PERM;
+    const vector unsigned int sl1_msk = ALTI_SL1_MSK;
+    const vector unsigned char sr1 = ALTI_SR;
+    const vector unsigned char sr1_perm = ALTI_SR_PERM;
+    const vector unsigned int sr1_msk = ALTI_SR_MSK;
+    const vector unsigned char perm = ALTI_PERM;
+    const vector unsigned int msk1 = ALTI_MSK;
+    vector unsigned int w, x, y, z;
+
+    z = a->s;
+    w = lung->s;
+    x = vec_perm(w, (vector unsigned int)perm, perm);
+    y = vec_perm(z, (vector unsigned int)sl1_perm, sl1_perm);
+    y = vec_sll(y, sl1);
+    y = vec_and(y, sl1_msk);
+    w = vec_xor(x, b->s);
+    w = vec_xor(w, y);
+    x = vec_perm(w, (vector unsigned int)sr1_perm, sr1_perm);
+    x = vec_srl(x, sr1);
+    x = vec_and(x, sr1_msk);
+    y = vec_and(w, msk1);
+    z = vec_xor(z, y);
+    r->s = vec_xor(z, x);
+    lung->s = w;
+}
+#elif defined(HAVE_SSE2)
+/**
+ * This function represents the recursion formula.
+ * @param r output 128-bit
+ * @param a a 128-bit part of the internal state array
+ * @param b a 128-bit part of the internal state array
+ * @param d a 128-bit part of the internal state array (I/O)
+ */
+inline static void do_recursion(w128_t *r, w128_t *a, w128_t *b, w128_t *u) {
+    __m128i v, w, x, y, z;
+
+    x = a->si;
+    z = _mm_slli_epi64(x, DSFMT_SL1);
+    y = _mm_shuffle_epi32(u->si, SSE2_SHUFF);
+    z = _mm_xor_si128(z, b->si);
+    y = _mm_xor_si128(y, z);
+
+    v = _mm_srli_epi64(y, DSFMT_SR);
+    w = _mm_and_si128(y, sse2_param_mask.i128);
+    v = _mm_xor_si128(v, x);
+    v = _mm_xor_si128(v, w);
+    r->si = v;
+    u->si = y;
+}
+#else
+/**
+ * This function represents the recursion formula.
+ * @param r output 128-bit
+ * @param a a 128-bit part of the internal state array
+ * @param b a 128-bit part of the internal state array
+ * @param lung a 128-bit part of the internal state array (I/O)
+ */
+inline static void do_recursion(w128_t *r, w128_t *a, w128_t * b,
+				w128_t *lung) {
+    uint64_t t0, t1, L0, L1;
+
+    t0 = a->u[0];
+    t1 = a->u[1];
+    L0 = lung->u[0];
+    L1 = lung->u[1];
+    lung->u[0] = (t0 << DSFMT_SL1) ^ (L1 >> 32) ^ (L1 << 32) ^ b->u[0];
+    lung->u[1] = (t1 << DSFMT_SL1) ^ (L0 >> 32) ^ (L0 << 32) ^ b->u[1];
+    r->u[0] = (lung->u[0] >> DSFMT_SR) ^ (lung->u[0] & DSFMT_MSK1) ^ t0;
+    r->u[1] = (lung->u[1] >> DSFMT_SR) ^ (lung->u[1] & DSFMT_MSK2) ^ t1;
+}
+#endif
+#endif
diff --git a/numpy/random/src/dsfmt/dSFMT-jump.c b/numpy/random/src/dsfmt/dSFMT-jump.c
new file mode 100644
index 000000000..1832bb885
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-jump.c
@@ -0,0 +1,184 @@
+/**
+ * @file dSFMT-jump.c
+ *
+ * @brief do jump using jump polynomial.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (The University of Tokyo)
+ *
+ * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto,
+ * Hiroshima University and The University of Tokyo.
+ * All rights reserved.
+ *
+ * The 3-clause BSD License is applied to this software, see
+ * LICENSE.txt
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+#include "dSFMT-params.h"
+#include "dSFMT.h"
+#include "dSFMT-jump.h"
+#include "dSFMT-common.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+    struct FIX_T {
+	int mexp;
+	uint64_t fix[4];
+    };
+
+    struct FIX_T fix_table[] = {
+	{521, {UINT64_C(0x3fff56977f035125),
+	       UINT64_C(0x3ff553857b015035),
+	       UINT64_C(0x4034434434434434),
+	       UINT64_C(0x0140151151351371)}},
+	{1279, {UINT64_C(0x3ff87befce70e89f),
+		UINT64_C(0x3ff5f6afa3c60868),
+		UINT64_C(0xa4ca4caccaccacdb),
+		UINT64_C(0x40444444444c44c4)}},
+	{4253, {UINT64_C(0x3ff85a66da51a81a),
+		UINT64_C(0x3ff4f4aeab9688eb),
+		UINT64_C(0x20524524534d34d3),
+		UINT64_C(0xc9cc9cc9cc9ccdcf)}},
+	{216091, {UINT64_C(0x3ff096d54a871071),
+		  UINT64_C(0x3ffafa9bfbd5d55d),
+		  UINT64_C(0x0470470470573573),
+		  UINT64_C(0x0250250251259259)}},
+	{0}
+    };
+
+    inline static void next_state(dsfmt_t * dsfmt);
+
+#if defined(HAVE_SSE2)
+/**
+ * add internal state of src to dest as F2-vector.
+ * @param dest destination state
+ * @param src source state
+ */
+    inline static void add(dsfmt_t *dest, dsfmt_t *src) {
+	int dp = dest->idx / 2;
+	int sp = src->idx / 2;
+	int diff = (sp - dp + DSFMT_N) % DSFMT_N;
+	int p;
+	int i;
+	for (i = 0; i < DSFMT_N - diff; i++) {
+	    p = i + diff;
+	    dest->status[i].si
+		= _mm_xor_si128(dest->status[i].si, src->status[p].si);
+	}
+	for (i = DSFMT_N - diff; i < DSFMT_N; i++) {
+	    p = i + diff - DSFMT_N;
+	    dest->status[i].si
+		= _mm_xor_si128(dest->status[i].si, src->status[p].si);
+	}
+	dest->status[DSFMT_N].si
+	    = _mm_xor_si128(dest->status[DSFMT_N].si,
+			    src->status[DSFMT_N].si);
+    }
+#else
+    inline static void add(dsfmt_t *dest, dsfmt_t *src) {
+	int dp = dest->idx / 2;
+	int sp = src->idx / 2;
+	int diff = (sp - dp + DSFMT_N) % DSFMT_N;
+	int p;
+	int i;
+	for (i = 0; i < DSFMT_N - diff; i++) {
+	    p = i + diff;
+	    dest->status[i].u[0] ^= src->status[p].u[0];
+	    dest->status[i].u[1] ^= src->status[p].u[1];
+	}
+	for (; i < DSFMT_N; i++) {
+	    p = i + diff - DSFMT_N;
+	    dest->status[i].u[0] ^= src->status[p].u[0];
+	    dest->status[i].u[1] ^= src->status[p].u[1];
+	}
+	dest->status[DSFMT_N].u[0] ^= src->status[DSFMT_N].u[0];
+	dest->status[DSFMT_N].u[1] ^= src->status[DSFMT_N].u[1];
+    }
+#endif
+
+/**
+ * calculate next state
+ * @param dsfmt dSFMT internal state
+ */
+    inline static void next_state(dsfmt_t * dsfmt) {
+	int idx = (dsfmt->idx / 2) % DSFMT_N;
+	w128_t * lung;
+	w128_t * pstate = &dsfmt->status[0];
+
+	lung = &pstate[DSFMT_N];
+	do_recursion(&pstate[idx],
+		     &pstate[idx],
+		     &pstate[(idx + DSFMT_POS1) % DSFMT_N],
+		     lung);
+	dsfmt->idx = (dsfmt->idx + 2) % DSFMT_N64;
+    }
+
+    inline static void add_fix(dsfmt_t * dsfmt) {
+	int i;
+	int index = -1;
+	for (i = 0; fix_table[i].mexp != 0; i++) {
+	    if (fix_table[i].mexp == DSFMT_MEXP) {
+		index = i;
+	    }
+	    if (fix_table[i].mexp > DSFMT_MEXP) {
+		break;
+	    }
+	}
+	if (index < 0) {
+	    return;
+	}
+	for (i = 0; i < DSFMT_N; i++) {
+	    dsfmt->status[i].u[0] ^= fix_table[index].fix[0];
+	    dsfmt->status[i].u[1] ^= fix_table[index].fix[1];
+	}
+	dsfmt->status[DSFMT_N].u[0] ^= fix_table[index].fix[2];
+	dsfmt->status[DSFMT_N].u[1] ^= fix_table[index].fix[3];
+    }
+
+/**
+ * jump ahead using jump_string
+ * @param dsfmt dSFMT internal state input and output.
+ * @param jump_string string which represents jump polynomial.
+ */
+    void dSFMT_jump(dsfmt_t * dsfmt, const char * jump_string) {
+	dsfmt_t work;
+	int index = dsfmt->idx;
+	int bits;
+	int i;
+	int j;
+	memset(&work, 0, sizeof(dsfmt_t));
+	add_fix(dsfmt);
+	dsfmt->idx = DSFMT_N64;
+
+	for (i = 0; jump_string[i] != '\0'; i++) {
+	    bits = jump_string[i];
+	    assert(isxdigit(bits));
+	    bits = tolower(bits);
+	    if (bits >= 'a' && bits <= 'f') {
+		bits = bits - 'a' + 10;
+	    } else {
+		bits = bits - '0';
+	    }
+	    bits = bits & 0x0f;
+	    for (j = 0; j < 4; j++) {
+		if ((bits & 1) != 0) {
+		    add(&work, dsfmt);
+		}
+		next_state(dsfmt);
+		bits = bits >> 1;
+	    }
+	}
+	*dsfmt = work;
+	add_fix(dsfmt);
+	dsfmt->idx = index;
+    }
+
+#if defined(__cplusplus)
+}
+#endif
diff --git a/numpy/random/src/dsfmt/dSFMT-jump.h b/numpy/random/src/dsfmt/dSFMT-jump.h
new file mode 100644
index 000000000..689f9499a
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-jump.h
@@ -0,0 +1,29 @@
+#pragma once
+#ifndef DSFMT_JUMP_H
+#define DSFMT_JUMP_H
+/**
+ * @file SFMT-jump.h
+ *
+ * @brief jump header file.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (The University of Tokyo)
+ *
+ * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto,
+ * Hiroshima University and The University of Tokyo.
+ * All rights reserved.
+ *
+ * The 3-clause BSD License is applied to this software, see
+ * LICENSE.txt
+ */
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "dSFMT.h"
+void dSFMT_jump(dsfmt_t *dsfmt, const char *jump_str);
+
+#if defined(__cplusplus)
+}
+#endif
+#endif
diff --git a/numpy/random/src/dsfmt/dSFMT-params.h b/numpy/random/src/dsfmt/dSFMT-params.h
new file mode 100644
index 000000000..aa0247800
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-params.h
@@ -0,0 +1,87 @@
+#ifndef DSFMT_PARAMS_H
+#define DSFMT_PARAMS_H
+
+#include "dSFMT.h"
+
+/*----------------------
+  the parameters of DSFMT
+  following definitions are in dSFMT-paramsXXXX.h file.
+  ----------------------*/
+/** the pick up position of the array.
+#define DSFMT_POS1 122 
+*/
+
+/** the parameter of shift left as four 32-bit registers.
+#define DSFMT_SL1 18
+ */
+
+/** the parameter of shift right as four 32-bit registers.
+#define DSFMT_SR1 12
+*/
+
+/** A bitmask, used in the recursion.  These parameters are introduced
+ * to break symmetry of SIMD.
+#define DSFMT_MSK1 (uint64_t)0xdfffffefULL
+#define DSFMT_MSK2 (uint64_t)0xddfecb7fULL
+*/
+
+/** These definitions are part of a 128-bit period certification vector.
+#define DSFMT_PCV1	UINT64_C(0x00000001)
+#define DSFMT_PCV2	UINT64_C(0x00000000)
+*/
+
+#define DSFMT_LOW_MASK  UINT64_C(0x000FFFFFFFFFFFFF)
+#define DSFMT_HIGH_CONST UINT64_C(0x3FF0000000000000)
+#define DSFMT_SR	12
+
+/* for sse2 */
+#if defined(HAVE_SSE2)
+  #define SSE2_SHUFF 0x1b
+#elif defined(HAVE_ALTIVEC)
+  #if defined(__APPLE__)  /* For OSX */
+    #define ALTI_SR (vector unsigned char)(4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
+    #define ALTI_SR_PERM \
+        (vector unsigned char)(15,0,1,2,3,4,5,6,15,8,9,10,11,12,13,14)
+    #define ALTI_SR_MSK \
+        (vector unsigned int)(0x000fffffU,0xffffffffU,0x000fffffU,0xffffffffU)
+    #define ALTI_PERM \
+        (vector unsigned char)(12,13,14,15,8,9,10,11,4,5,6,7,0,1,2,3)
+  #else
+    #define ALTI_SR      {4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4}
+    #define ALTI_SR_PERM {15,0,1,2,3,4,5,6,15,8,9,10,11,12,13,14}
+    #define ALTI_SR_MSK  {0x000fffffU,0xffffffffU,0x000fffffU,0xffffffffU}
+    #define ALTI_PERM    {12,13,14,15,8,9,10,11,4,5,6,7,0,1,2,3}
+  #endif
+#endif
+
+#if DSFMT_MEXP == 521
+  #include "dSFMT-params521.h"
+#elif DSFMT_MEXP == 1279
+  #include "dSFMT-params1279.h"
+#elif DSFMT_MEXP == 2203
+  #include "dSFMT-params2203.h"
+#elif DSFMT_MEXP == 4253
+  #include "dSFMT-params4253.h"
+#elif DSFMT_MEXP == 11213
+  #include "dSFMT-params11213.h"
+#elif DSFMT_MEXP == 19937
+  #include "dSFMT-params19937.h"
+#elif DSFMT_MEXP == 44497
+  #include "dSFMT-params44497.h"
+#elif DSFMT_MEXP == 86243
+  #include "dSFMT-params86243.h"
+#elif DSFMT_MEXP == 132049
+  #include "dSFMT-params132049.h"
+#elif DSFMT_MEXP == 216091
+  #include "dSFMT-params216091.h"
+#else
+#ifdef __GNUC__
+  #error "DSFMT_MEXP is not valid."
+  #undef DSFMT_MEXP
+#else
+  #undef DSFMT_MEXP
+#endif
+
+#endif
+
+#endif /* DSFMT_PARAMS_H */
diff --git a/numpy/random/src/dsfmt/dSFMT-params19937.h b/numpy/random/src/dsfmt/dSFMT-params19937.h
new file mode 100644
index 000000000..a600b0dbc
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-params19937.h
@@ -0,0 +1,40 @@
+#ifndef DSFMT_PARAMS19937_H
+#define DSFMT_PARAMS19937_H
+
+/* #define DSFMT_N	191 */
+/* #define DSFMT_MAXDEGREE	19992 */
+#define DSFMT_POS1	117
+#define DSFMT_SL1	19
+#define DSFMT_MSK1	UINT64_C(0x000ffafffffffb3f)
+#define DSFMT_MSK2	UINT64_C(0x000ffdfffc90fffd)
+#define DSFMT_MSK32_1	0x000ffaffU
+#define DSFMT_MSK32_2	0xfffffb3fU
+#define DSFMT_MSK32_3	0x000ffdffU
+#define DSFMT_MSK32_4	0xfc90fffdU
+#define DSFMT_FIX1	UINT64_C(0x90014964b32f4329)
+#define DSFMT_FIX2	UINT64_C(0x3b8d12ac548a7c7a)
+#define DSFMT_PCV1	UINT64_C(0x3d84e1ac0dc82880)
+#define DSFMT_PCV2	UINT64_C(0x0000000000000001)
+#define DSFMT_IDSTR	"dSFMT2-19937:117-19:ffafffffffb3f-ffdfffc90fffd"
+
+
+/* PARAMETERS FOR ALTIVEC */
+#if defined(__APPLE__)	/* For OSX */
+    #define ALTI_SL1 	(vector unsigned char)(3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3)
+    #define ALTI_SL1_PERM \
+	(vector unsigned char)(2,3,4,5,6,7,30,30,10,11,12,13,14,15,0,1)
+    #define ALTI_SL1_MSK \
+	(vector unsigned int)(0xffffffffU,0xfff80000U,0xffffffffU,0xfff80000U)
+    #define ALTI_MSK	(vector unsigned int)(DSFMT_MSK32_1, \
+			DSFMT_MSK32_2, DSFMT_MSK32_3, DSFMT_MSK32_4)
+#else	/* For OTHER OSs(Linux?) */
+    #define ALTI_SL1 	{3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3}
+    #define ALTI_SL1_PERM \
+	{2,3,4,5,6,7,30,30,10,11,12,13,14,15,0,1}
+    #define ALTI_SL1_MSK \
+	{0xffffffffU,0xfff80000U,0xffffffffU,0xfff80000U}
+    #define ALTI_MSK \
+	{DSFMT_MSK32_1, DSFMT_MSK32_2, DSFMT_MSK32_3, DSFMT_MSK32_4}
+#endif
+
+#endif /* DSFMT_PARAMS19937_H */
diff --git a/numpy/random/src/dsfmt/dSFMT-poly.h b/numpy/random/src/dsfmt/dSFMT-poly.h
new file mode 100644
index 000000000..f8e15c3eb
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-poly.h
@@ -0,0 +1,53 @@
+static const char * poly_128 =
+"f4dfa6c62049d0776e0bf6f1e953f3aa38abb113df86be024eab3773ad5f2b82ead936022e656dff7e562691c59dd5f7d2"
+"566b78d9669002503c4ddb1888a49f32333f515e6c60c4ecd221078ec6f26f0a90f4875067ca1f399a99775037adf90556"
+"6e2c7e6b42131420f8f04f112c92621c9b1502f2a8aefad6c667904af62f0d55e02d396902d3b89450103c5ce5fe0408d9"
+"7cbb864861b49e4e42048ff3310b48faac55095a7f422eea4aade752f947f947c6be0a0c665bdea099246ab9eff658ea8c"
+"a468bf49d0227748367878de06d7bd86ea6708fcac6e252f5f00f04309b2aac3036b64afb39d990427c6c9f03477cc7e93"
+"5c43c0e61bc161db8eb15516eee8cb377ecbc1849207990fb6778721b29bfe0d89bfda1b3772fa5b0b1f7ec3daf3605203"
+"2285898c6f6396f55010c31f8201b7e2e51d94f920bfe57684c5415cc342cb39a0045d9793d13cf8646096daeb8bb9bfc2"
+"0a90de8f2426da8733267a9b9674f32154e8f84a9932223a2ca3c787d0b66df6675febbdfcba2f9cef09c621c57e11098b"
+"3289c77397aaae8b104642ffe0c4b75598efbc53745984d68b4d6656cae299ae2be55217a9a02b009ca7be32f47fbe434b"
+"ce4914a34d0c9b0085bede9b8a99319c34660d66f0124b5a7714c4bf3cbfec3ee43ed817087168bad80133bebaeeb68cf7"
+"929a24d1bb3de831a8340d220906ab04159cf94b21d5ee813bd7c80f10f01b43052af530917513b169254c25d6fcfe6cb4"
+"20d6ce92f54886ef6eaf9a5ba35e893ff593834d05ddf28899e42d729c7df3d21ef036020789739366f0c11ec52ff92a0b"
+"fd8ba69508e27b20fabb8217bd36b90e5aa918159ac87913bc7b46c04e366c23c92807fbe9c6a407e6a4db0b4fc23c3b6c"
+"706b5ca058fe8c190f849f18d16d6b48b5ed760eb202fd566291a799420b9654e08b8118bcbfead8e9dd2fdb9b053e9bdf"
+"b665285c78718f726d0b3d6c37e116428ec9ac9db2637259e4e8d6402bbada46c6bdb03985e19a82e9b4e57de1b025a3cb"
+"1f850beae7e8da9941655825bce0e89d536b6ee9064865b1a85c185e9fc9cb7f435de13d44773c00eed442a286e4ab807e"
+"3cab4dc3441d1b7d2af693812ae8b39652bb8c835fc895d13d6da93541afeadeee450475c29f3b2dfa8ef1c1e2547463b2"
+"cc2f0ff7a42ac4dd35e25c4fa030d2d2766fbe9f2d04c1304671747bace2f7dd55142bfa60f8cbc968bfc3d7a342152dc6"
+"84a0fb5a32c0962a62b5220ac0f72add9d8b84d6cc76b97d03245e01fc8da3414a49bb4075d3488f29b56dc42ba69e3b58"
+"529448c943ecfd98b3784a39d0b8609a8fb945e757f4569f53bd2cf80f7f638acf5b67fe9c560a3b7b0cf7e0398f31aa8b"
+"03cf9c62b24296b6d8596b694469a02686c38daa16a1ef86e012d61a2f7de1693a5c00b3685175caec3c67146477eba548"
+"30f1d546cb18a553779aa46adb4f2010e33f3def847c7d89b51a8462b227605f6c920fd558a6daf64bc98682e508ae960c"
+"0c571870e603ba1fce0c13d53176f353fd319959e13db93eae1359f06e3dd4767c04f824cf34ec7bf8f60161ba1a615db8"
+"2852eca9e3869afa711ab9a090660b0dc6cfbea310dda77e02310fbaeacd2636f975838c2dbcdbe9ac2cd85cee28f5e3f0"
+"c73abf62f9fa02cd79a7606b7ba855db68a07848b057c3aaf38f1a70086e14616f6f88305a1f9ce6b41378a620d4db3e0e"
+"7e1d421590dccaeff86212e232eeb5eb8a8d33a8c9b25ae88f3a7bd5032b4efa68f8af3186a02ffcbf5456f12beccace94"
+"c81c360cc4a0dcc642b59f991eec68c59af78139ca60b96d6a18e9535f8995e89bd2cf6a0aef3acffd33d1c0c1b79b6641"
+"4a91d9f65b2b4ec65844b96f725d2b4b0c309f3eb9d714e9dd939bbdfd85ce8fb43679aeab13f6c29549949503c9466dbd"
+"337c4cdde46d6eacd15f21f4d8fdeaa627a47884c88a9c85f0b731d271a8ea7cb9e04a4a149c23c10f56b3a0476dc77a99"
+"9d6e4f813e4b0f805e2a693e2ae4ae0ecc423c9ba5d17b42e691abf83784a582f2b1fd85d1e0a27ba38a500963568b2450"
+"363d2c5e3f7b8ba3e5b56e4e9f745a3a710bf2ae233c303068c532ce78ff031e6ab28b705dd94d7db4500909edb5626b8c"
+"9bd5ff4f0b4741388f0b91563ee516934c013e901572cba005ac5c535f4f107903be9af7b2793dfb61b5070facbe71eefe"
+"1b5600f975c8c38c3a2350d78beadfecb78e981164ae8bc866e732972d3ceef4aac68e15861f9b881d9b51b4edece150bc"
+"124b07645defb4202ef5d0e0962db98cae6ed459561c93c74c20bd64362e4f4fffc389a6cd80514604ff22eecc10c9cbc7"
+"981d19a8102b24146354c463107c9dc070e29e70df3578022acf72289ef071ab9f9402a544d0399f1b1e5f206b6d46d445"
+"f6d612a490e72918e00c853eda8493bef511149e80c9ab56e8b4b8cba3987249f77d060e61760e5792ac321c987c03c260"
+"6e9393a7970212992cdbd16448078d5039d4c2c3199714f53278f4f7b1d2e514cf95bdfc078b8bb0db659cb2c3f5cc0289"
+"0ea84f05d414c88d2db9e9f8455659b9fa6254405317245fa070d6970cafb4dadb2522b490a5c8e02fe973a8cdbfbfbdbf"
+"b01535099ffba3d3896bc4d1189fc570c3e6fdc6469265b8da912772e75dd62ab71be507f700d56cac5e68fd6b57ec1661"
+"68ab5258a69625c142a5b1b3519f94be1bde5e51d3bd8ea0c12d5af2fe4615b1b7bd4a96628a4fabc65925ff09718f63bb"
+"ebaad98f89bd9543a27b3ff3b5d8bfa89f941a5eb8cc005ccd4a705190e1c9dc6a9f4264e5ee658520a4438e92de854bff"
+"c39f8dc7dfbb5de4f14ba63ea16a37d14a7b4610f95b6cffd55e4679b29cedbdf20e7bd16da822fad910c359ee3a68e48a"
+"ae6e769b0e291d5d3aa3e2ca9d8d23abe8a1d5349f4991e9300852cc0befb20c2fc0d169306b260763344024f8092cbcc2"
+"4c6807363e9fc548a30d5faab3a94b2af0782a2942be80c45d8b0587efd587394ef33c33022436e285806ddffdd32fe363"
+"45c3c38ed8d680abeb7a028b44ee6f94d060a14c7019bb6af1f1b5f0a562957d19826d8cc216f9b908c989ccd5415e3525"
+"dfe9422ffb5b50b7cc3083dc325544751e5683535d7439d3da2b0bb73bea551dd99e04e0e793804f4774eb6b1daf781d9c"
+"aa5128274e599e847862fe309027813d3e4eda0bbeb7201856a5c5d8370e44dabff0bb229c723ba0a6bcf29c44536147de"
+"11b7835991018100105bd4329217f7386903fe8e7363cd7b3e893244e245e0a187467664c05b0be1fd429722b9b9a5e319"
+"8147fad72776e8a63aab9054fa9d259af0198d088d71d132e6068676a8e9ebb0f616b51ee34aac39c2c2221c7112401727"
+"0d75ff4a048363c389e04e9b440ad2032a381ac2cfc54f409caa791e65ee4f5d6cd035008f219b88a803a7382ae447bf65"
+"a3df2176b25b3b7b67dabe34decd9a1384dc7a003916ca8fbcb29b3ad6fd8eac5bbbaa3bdfa6c6a3ad9427c4f3ed79fea2"
+"6e14c8ce5fa3b4f82c5f7b6d2125916753a7b92ce9b46d45";
\ No newline at end of file
diff --git a/numpy/random/src/dsfmt/dSFMT-test-gen.c b/numpy/random/src/dsfmt/dSFMT-test-gen.c
new file mode 100644
index 000000000..697a3010a
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT-test-gen.c
@@ -0,0 +1,58 @@
+/*
+ * cl dSFMT-test-gen.c dSFMT.c -DHAVE_SSE2 -DDSFMT_MEXP=19937 /Ox
+ *
+ * gcc dSFMT-test-gen.c dSFMT.c -DHAVE_SSE2 -DDSFMT_MEXP=19937 -o dSFMT
+ */
+
+#include <inttypes.h>
+#include <stdio.h>
+
+#include "dSFMT.h"
+
+
+int main(void) {
+  int i;
+  double d;
+  uint64_t *temp;
+  uint32_t seed = 1UL;
+  dsfmt_t state;
+  dsfmt_init_gen_rand(&state, seed);
+  double out[1000];
+  dsfmt_fill_array_close1_open2(&state, out, 1000);
+
+  FILE *fp;
+  fp = fopen("dSFMT-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, %" PRIu32 "\n", seed);
+  for (i = 0; i < 1000; i++) {
+    d = out[i];
+    temp = (uint64_t *)&d;
+    fprintf(fp, "%d, %" PRIu64 "\n", i, *temp);
+    if (i==999) {
+        printf("%d, %" PRIu64 "\n", i, *temp);
+    }
+  }
+  fclose(fp);
+
+  seed = 123456789UL;
+  dsfmt_init_gen_rand(&state, seed);
+  dsfmt_fill_array_close1_open2(&state, out, 1000);
+  fp = fopen("dSFMT-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, %" PRIu32 "\n", seed);
+  for (i = 0; i < 1000; i++) {
+    d = out[i];
+    temp = (uint64_t *)&d;
+    fprintf(fp, "%d, %" PRIu64 "\n", i, *temp);
+    if (i==999) {
+        printf("%d, %" PRIu64 "\n", i, *temp);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/dsfmt/dSFMT.c b/numpy/random/src/dsfmt/dSFMT.c
new file mode 100644
index 000000000..0f122c26c
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT.c
@@ -0,0 +1,626 @@
+/**
+ * @file dSFMT.c
+ * @brief double precision SIMD-oriented Fast Mersenne Twister (dSFMT)
+ * based on IEEE 754 format.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (Hiroshima University)
+ *
+ * Copyright (C) 2007,2008 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+ * University. All rights reserved.
+ *
+ * The new BSD License is applied to this software, see LICENSE.txt
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "dSFMT-params.h"
+
+#include "dSFMT-common.h"
+#include "dSFMT-jump.h"
+#include "dSFMT-poly.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/** dsfmt internal state vector */
+dsfmt_t dsfmt_global_data;
+/** dsfmt mexp for check */
+static const int dsfmt_mexp = DSFMT_MEXP;
+
+/*----------------
+  STATIC FUNCTIONS
+  ----------------*/
+inline static uint32_t ini_func1(uint32_t x);
+inline static uint32_t ini_func2(uint32_t x);
+inline static void gen_rand_array_c1o2(dsfmt_t *dsfmt, w128_t *array, int size);
+inline static void gen_rand_array_c0o1(dsfmt_t *dsfmt, w128_t *array, int size);
+inline static void gen_rand_array_o0c1(dsfmt_t *dsfmt, w128_t *array, int size);
+inline static void gen_rand_array_o0o1(dsfmt_t *dsfmt, w128_t *array, int size);
+inline static int idxof(int i);
+static void initial_mask(dsfmt_t *dsfmt);
+static void period_certification(dsfmt_t *dsfmt);
+
+#if defined(HAVE_SSE2)
+/** 1 in 64bit for sse2 */
+static const union X128I_T sse2_int_one = {{1, 1}};
+/** 2.0 double for sse2 */
+static const union X128D_T sse2_double_two = {{2.0, 2.0}};
+/** -1.0 double for sse2 */
+static const union X128D_T sse2_double_m_one = {{-1.0, -1.0}};
+#endif
+
+/**
+ * This function simulate a 32-bit array index overlapped to 64-bit
+ * array of LITTLE ENDIAN in BIG ENDIAN machine.
+ */
+#if defined(DSFMT_BIG_ENDIAN)
+inline static int idxof(int i) { return i ^ 1; }
+#else
+inline static int idxof(int i) { return i; }
+#endif
+
+#if defined(HAVE_SSE2)
+/**
+ * This function converts the double precision floating point numbers which
+ * distribute uniformly in the range [1, 2) to those which distribute uniformly
+ * in the range [0, 1).
+ * @param w 128bit stracture of double precision floating point numbers (I/O)
+ */
+inline static void convert_c0o1(w128_t *w) {
+  w->sd = _mm_add_pd(w->sd, sse2_double_m_one.d128);
+}
+
+/**
+ * This function converts the double precision floating point numbers which
+ * distribute uniformly in the range [1, 2) to those which distribute uniformly
+ * in the range (0, 1].
+ * @param w 128bit stracture of double precision floating point numbers (I/O)
+ */
+inline static void convert_o0c1(w128_t *w) {
+  w->sd = _mm_sub_pd(sse2_double_two.d128, w->sd);
+}
+
+/**
+ * This function converts the double precision floating point numbers which
+ * distribute uniformly in the range [1, 2) to those which distribute uniformly
+ * in the range (0, 1).
+ * @param w 128bit stracture of double precision floating point numbers (I/O)
+ */
+inline static void convert_o0o1(w128_t *w) {
+  w->si = _mm_or_si128(w->si, sse2_int_one.i128);
+  w->sd = _mm_add_pd(w->sd, sse2_double_m_one.d128);
+}
+#else /* standard C and altivec */
+/**
+ * This function converts the double precision floating point numbers which
+ * distribute uniformly in the range [1, 2) to those which distribute uniformly
+ * in the range [0, 1).
+ * @param w 128bit stracture of double precision floating point numbers (I/O)
+ */
+inline static void convert_c0o1(w128_t *w) {
+  w->d[0] -= 1.0;
+  w->d[1] -= 1.0;
+}
+
+/**
+ * This function converts the double precision floating point numbers which
+ * distribute uniformly in the range [1, 2) to those which distribute uniformly
+ * in the range (0, 1].
+ * @param w 128bit stracture of double precision floating point numbers (I/O)
+ */
+inline static void convert_o0c1(w128_t *w) {
+  w->d[0] = 2.0 - w->d[0];
+  w->d[1] = 2.0 - w->d[1];
+}
+
+/**
+ * This function converts the double precision floating point numbers which
+ * distribute uniformly in the range [1, 2) to those which distribute uniformly
+ * in the range (0, 1).
+ * @param w 128bit stracture of double precision floating point numbers (I/O)
+ */
+inline static void convert_o0o1(w128_t *w) {
+  w->u[0] |= 1;
+  w->u[1] |= 1;
+  w->d[0] -= 1.0;
+  w->d[1] -= 1.0;
+}
+#endif
+
+/**
+ * This function fills the user-specified array with double precision
+ * floating point pseudorandom numbers of the IEEE 754 format.
+ * @param dsfmt dsfmt state vector.
+ * @param array an 128-bit array to be filled by pseudorandom numbers.
+ * @param size number of 128-bit pseudorandom numbers to be generated.
+ */
+inline static void gen_rand_array_c1o2(dsfmt_t *dsfmt, w128_t *array,
+                                       int size) {
+  int i, j;
+  w128_t lung;
+
+  lung = dsfmt->status[DSFMT_N];
+  do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1], &lung);
+  for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &dsfmt->status[i + DSFMT_POS1],
+                 &lung);
+  }
+  for (; i < DSFMT_N; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &array[i + DSFMT_POS1 - DSFMT_N],
+                 &lung);
+  }
+  for (; i < size - DSFMT_N; i++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+  }
+  for (j = 0; j < 2 * DSFMT_N - size; j++) {
+    dsfmt->status[j] = array[j + size - DSFMT_N];
+  }
+  for (; i < size; i++, j++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    dsfmt->status[j] = array[i];
+  }
+  dsfmt->status[DSFMT_N] = lung;
+}
+
+/**
+ * This function fills the user-specified array with double precision
+ * floating point pseudorandom numbers of the IEEE 754 format.
+ * @param dsfmt dsfmt state vector.
+ * @param array an 128-bit array to be filled by pseudorandom numbers.
+ * @param size number of 128-bit pseudorandom numbers to be generated.
+ */
+inline static void gen_rand_array_c0o1(dsfmt_t *dsfmt, w128_t *array,
+                                       int size) {
+  int i, j;
+  w128_t lung;
+
+  lung = dsfmt->status[DSFMT_N];
+  do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1], &lung);
+  for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &dsfmt->status[i + DSFMT_POS1],
+                 &lung);
+  }
+  for (; i < DSFMT_N; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &array[i + DSFMT_POS1 - DSFMT_N],
+                 &lung);
+  }
+  for (; i < size - DSFMT_N; i++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    convert_c0o1(&array[i - DSFMT_N]);
+  }
+  for (j = 0; j < 2 * DSFMT_N - size; j++) {
+    dsfmt->status[j] = array[j + size - DSFMT_N];
+  }
+  for (; i < size; i++, j++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    dsfmt->status[j] = array[i];
+    convert_c0o1(&array[i - DSFMT_N]);
+  }
+  for (i = size - DSFMT_N; i < size; i++) {
+    convert_c0o1(&array[i]);
+  }
+  dsfmt->status[DSFMT_N] = lung;
+}
+
+/**
+ * This function fills the user-specified array with double precision
+ * floating point pseudorandom numbers of the IEEE 754 format.
+ * @param dsfmt dsfmt state vector.
+ * @param array an 128-bit array to be filled by pseudorandom numbers.
+ * @param size number of 128-bit pseudorandom numbers to be generated.
+ */
+inline static void gen_rand_array_o0o1(dsfmt_t *dsfmt, w128_t *array,
+                                       int size) {
+  int i, j;
+  w128_t lung;
+
+  lung = dsfmt->status[DSFMT_N];
+  do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1], &lung);
+  for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &dsfmt->status[i + DSFMT_POS1],
+                 &lung);
+  }
+  for (; i < DSFMT_N; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &array[i + DSFMT_POS1 - DSFMT_N],
+                 &lung);
+  }
+  for (; i < size - DSFMT_N; i++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    convert_o0o1(&array[i - DSFMT_N]);
+  }
+  for (j = 0; j < 2 * DSFMT_N - size; j++) {
+    dsfmt->status[j] = array[j + size - DSFMT_N];
+  }
+  for (; i < size; i++, j++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    dsfmt->status[j] = array[i];
+    convert_o0o1(&array[i - DSFMT_N]);
+  }
+  for (i = size - DSFMT_N; i < size; i++) {
+    convert_o0o1(&array[i]);
+  }
+  dsfmt->status[DSFMT_N] = lung;
+}
+
+/**
+ * This function fills the user-specified array with double precision
+ * floating point pseudorandom numbers of the IEEE 754 format.
+ * @param dsfmt dsfmt state vector.
+ * @param array an 128-bit array to be filled by pseudorandom numbers.
+ * @param size number of 128-bit pseudorandom numbers to be generated.
+ */
+inline static void gen_rand_array_o0c1(dsfmt_t *dsfmt, w128_t *array,
+                                       int size) {
+  int i, j;
+  w128_t lung;
+
+  lung = dsfmt->status[DSFMT_N];
+  do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1], &lung);
+  for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &dsfmt->status[i + DSFMT_POS1],
+                 &lung);
+  }
+  for (; i < DSFMT_N; i++) {
+    do_recursion(&array[i], &dsfmt->status[i], &array[i + DSFMT_POS1 - DSFMT_N],
+                 &lung);
+  }
+  for (; i < size - DSFMT_N; i++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    convert_o0c1(&array[i - DSFMT_N]);
+  }
+  for (j = 0; j < 2 * DSFMT_N - size; j++) {
+    dsfmt->status[j] = array[j + size - DSFMT_N];
+  }
+  for (; i < size; i++, j++) {
+    do_recursion(&array[i], &array[i - DSFMT_N],
+                 &array[i + DSFMT_POS1 - DSFMT_N], &lung);
+    dsfmt->status[j] = array[i];
+    convert_o0c1(&array[i - DSFMT_N]);
+  }
+  for (i = size - DSFMT_N; i < size; i++) {
+    convert_o0c1(&array[i]);
+  }
+  dsfmt->status[DSFMT_N] = lung;
+}
+
+/**
+ * This function represents a function used in the initialization
+ * by init_by_array
+ * @param x 32-bit integer
+ * @return 32-bit integer
+ */
+static uint32_t ini_func1(uint32_t x) {
+  return (x ^ (x >> 27)) * (uint32_t)1664525UL;
+}
+
+/**
+ * This function represents a function used in the initialization
+ * by init_by_array
+ * @param x 32-bit integer
+ * @return 32-bit integer
+ */
+static uint32_t ini_func2(uint32_t x) {
+  return (x ^ (x >> 27)) * (uint32_t)1566083941UL;
+}
+
+/**
+ * This function initializes the internal state array to fit the IEEE
+ * 754 format.
+ * @param dsfmt dsfmt state vector.
+ */
+static void initial_mask(dsfmt_t *dsfmt) {
+  int i;
+  uint64_t *psfmt;
+
+  psfmt = &dsfmt->status[0].u[0];
+  for (i = 0; i < DSFMT_N * 2; i++) {
+    psfmt[i] = (psfmt[i] & DSFMT_LOW_MASK) | DSFMT_HIGH_CONST;
+  }
+}
+
+/**
+ * This function certificate the period of 2^{SFMT_MEXP}-1.
+ * @param dsfmt dsfmt state vector.
+ */
+static void period_certification(dsfmt_t *dsfmt) {
+  uint64_t pcv[2] = {DSFMT_PCV1, DSFMT_PCV2};
+  uint64_t tmp[2];
+  uint64_t inner;
+  int i;
+#if (DSFMT_PCV2 & 1) != 1
+  int j;
+  uint64_t work;
+#endif
+
+  tmp[0] = (dsfmt->status[DSFMT_N].u[0] ^ DSFMT_FIX1);
+  tmp[1] = (dsfmt->status[DSFMT_N].u[1] ^ DSFMT_FIX2);
+
+  inner = tmp[0] & pcv[0];
+  inner ^= tmp[1] & pcv[1];
+  for (i = 32; i > 0; i >>= 1) {
+    inner ^= inner >> i;
+  }
+  inner &= 1;
+  /* check OK */
+  if (inner == 1) {
+    return;
+  }
+    /* check NG, and modification */
+#if (DSFMT_PCV2 & 1) == 1
+  dsfmt->status[DSFMT_N].u[1] ^= 1;
+#else
+  for (i = 1; i >= 0; i--) {
+    work = 1;
+    for (j = 0; j < 64; j++) {
+      if ((work & pcv[i]) != 0) {
+        dsfmt->status[DSFMT_N].u[i] ^= work;
+        return;
+      }
+      work = work << 1;
+    }
+  }
+#endif
+  return;
+}
+
+/*----------------
+  PUBLIC FUNCTIONS
+  ----------------*/
+/**
+ * This function returns the identification string.  The string shows
+ * the Mersenne exponent, and all parameters of this generator.
+ * @return id string.
+ */
+const char *dsfmt_get_idstring(void) { return DSFMT_IDSTR; }
+
+/**
+ * This function returns the minimum size of array used for \b
+ * fill_array functions.
+ * @return minimum size of array used for fill_array functions.
+ */
+int dsfmt_get_min_array_size(void) { return DSFMT_N64; }
+
+/**
+ * This function fills the internal state array with double precision
+ * floating point pseudorandom numbers of the IEEE 754 format.
+ * @param dsfmt dsfmt state vector.
+ */
+void dsfmt_gen_rand_all(dsfmt_t *dsfmt) {
+  int i;
+  w128_t lung;
+
+  lung = dsfmt->status[DSFMT_N];
+  do_recursion(&dsfmt->status[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1],
+               &lung);
+  for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
+    do_recursion(&dsfmt->status[i], &dsfmt->status[i],
+                 &dsfmt->status[i + DSFMT_POS1], &lung);
+  }
+  for (; i < DSFMT_N; i++) {
+    do_recursion(&dsfmt->status[i], &dsfmt->status[i],
+                 &dsfmt->status[i + DSFMT_POS1 - DSFMT_N], &lung);
+  }
+  dsfmt->status[DSFMT_N] = lung;
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range [1, 2) to the
+ * specified array[] by one call. The number of pseudorandom numbers
+ * is specified by the argument \b size, which must be at least (SFMT_MEXP
+ * / 128) * 2 and a multiple of two.  The function
+ * get_min_array_size() returns this minimum size.  The generation by
+ * this function is much faster than the following fill_array_xxx functions.
+ *
+ * For initialization, init_gen_rand() or init_by_array() must be called
+ * before the first call of this function. This function can not be
+ * used after calling genrand_xxx functions, without initialization.
+ *
+ * @param dsfmt dsfmt state vector.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.  The pointer to the array must be "aligned"
+ * (namely, must be a multiple of 16) in the SIMD version, since it
+ * refers to the address of a 128-bit integer.  In the standard C
+ * version, the pointer is arbitrary.
+ *
+ * @param size the number of 64-bit pseudorandom integers to be
+ * generated.  size must be a multiple of 2, and greater than or equal
+ * to (SFMT_MEXP / 128) * 2.
+ *
+ * @note \b memalign or \b posix_memalign is available to get aligned
+ * memory. Mac OSX doesn't have these functions, but \b malloc of OSX
+ * returns the pointer to the aligned memory block.
+ */
+void dsfmt_fill_array_close1_open2(dsfmt_t *dsfmt, double array[], int size) {
+  assert(size % 2 == 0);
+  assert(size >= DSFMT_N64);
+  gen_rand_array_c1o2(dsfmt, (w128_t *)array, size / 2);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range (0, 1] to the
+ * specified array[] by one call. This function is the same as
+ * fill_array_close1_open2() except the distribution range.
+ *
+ * @param dsfmt dsfmt state vector.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa fill_array_close1_open2()
+ */
+void dsfmt_fill_array_open_close(dsfmt_t *dsfmt, double array[], int size) {
+  assert(size % 2 == 0);
+  assert(size >= DSFMT_N64);
+  gen_rand_array_o0c1(dsfmt, (w128_t *)array, size / 2);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range [0, 1) to the
+ * specified array[] by one call. This function is the same as
+ * fill_array_close1_open2() except the distribution range.
+ *
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param dsfmt dsfmt state vector.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa fill_array_close1_open2()
+ */
+void dsfmt_fill_array_close_open(dsfmt_t *dsfmt, double array[], int size) {
+  assert(size % 2 == 0);
+  assert(size >= DSFMT_N64);
+  gen_rand_array_c0o1(dsfmt, (w128_t *)array, size / 2);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range (0, 1) to the
+ * specified array[] by one call. This function is the same as
+ * fill_array_close1_open2() except the distribution range.
+ *
+ * @param dsfmt dsfmt state vector.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa fill_array_close1_open2()
+ */
+void dsfmt_fill_array_open_open(dsfmt_t *dsfmt, double array[], int size) {
+  assert(size % 2 == 0);
+  assert(size >= DSFMT_N64);
+  gen_rand_array_o0o1(dsfmt, (w128_t *)array, size / 2);
+}
+
+#if defined(__INTEL_COMPILER)
+#pragma warning(disable : 981)
+#endif
+/**
+ * This function initializes the internal state array with a 32-bit
+ * integer seed.
+ * @param dsfmt dsfmt state vector.
+ * @param seed a 32-bit integer used as the seed.
+ * @param mexp caller's mersenne expornent
+ */
+void dsfmt_chk_init_gen_rand(dsfmt_t *dsfmt, uint32_t seed, int mexp) {
+  int i;
+  uint32_t *psfmt;
+
+  /* make sure caller program is compiled with the same MEXP */
+  if (mexp != dsfmt_mexp) {
+    fprintf(stderr, "DSFMT_MEXP doesn't match with dSFMT.c\n");
+    exit(1);
+  }
+  psfmt = &dsfmt->status[0].u32[0];
+  psfmt[idxof(0)] = seed;
+  for (i = 1; i < (DSFMT_N + 1) * 4; i++) {
+    psfmt[idxof(i)] =
+        1812433253UL * (psfmt[idxof(i - 1)] ^ (psfmt[idxof(i - 1)] >> 30)) + i;
+  }
+  initial_mask(dsfmt);
+  period_certification(dsfmt);
+  dsfmt->idx = DSFMT_N64;
+}
+
+/**
+ * This function initializes the internal state array,
+ * with an array of 32-bit integers used as the seeds
+ * @param dsfmt dsfmt state vector.
+ * @param init_key the array of 32-bit integers, used as a seed.
+ * @param key_length the length of init_key.
+ * @param mexp caller's mersenne expornent
+ */
+void dsfmt_chk_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
+                             int key_length, int mexp) {
+  int i, j, count;
+  uint32_t r;
+  uint32_t *psfmt32;
+  int lag;
+  int mid;
+  int size = (DSFMT_N + 1) * 4; /* pulmonary */
+
+  /* make sure caller program is compiled with the same MEXP */
+  if (mexp != dsfmt_mexp) {
+    fprintf(stderr, "DSFMT_MEXP doesn't match with dSFMT.c\n");
+    exit(1);
+  }
+  if (size >= 623) {
+    lag = 11;
+  } else if (size >= 68) {
+    lag = 7;
+  } else if (size >= 39) {
+    lag = 5;
+  } else {
+    lag = 3;
+  }
+  mid = (size - lag) / 2;
+
+  psfmt32 = &dsfmt->status[0].u32[0];
+  memset(dsfmt->status, 0x8b, sizeof(dsfmt->status));
+  if (key_length + 1 > size) {
+    count = key_length + 1;
+  } else {
+    count = size;
+  }
+  r = ini_func1(psfmt32[idxof(0)] ^ psfmt32[idxof(mid % size)] ^
+                psfmt32[idxof((size - 1) % size)]);
+  psfmt32[idxof(mid % size)] += r;
+  r += key_length;
+  psfmt32[idxof((mid + lag) % size)] += r;
+  psfmt32[idxof(0)] = r;
+  count--;
+  for (i = 1, j = 0; (j < count) && (j < key_length); j++) {
+    r = ini_func1(psfmt32[idxof(i)] ^ psfmt32[idxof((i + mid) % size)] ^
+                  psfmt32[idxof((i + size - 1) % size)]);
+    psfmt32[idxof((i + mid) % size)] += r;
+    r += init_key[j] + i;
+    psfmt32[idxof((i + mid + lag) % size)] += r;
+    psfmt32[idxof(i)] = r;
+    i = (i + 1) % size;
+  }
+  for (; j < count; j++) {
+    r = ini_func1(psfmt32[idxof(i)] ^ psfmt32[idxof((i + mid) % size)] ^
+                  psfmt32[idxof((i + size - 1) % size)]);
+    psfmt32[idxof((i + mid) % size)] += r;
+    r += i;
+    psfmt32[idxof((i + mid + lag) % size)] += r;
+    psfmt32[idxof(i)] = r;
+    i = (i + 1) % size;
+  }
+  for (j = 0; j < size; j++) {
+    r = ini_func2(psfmt32[idxof(i)] + psfmt32[idxof((i + mid) % size)] +
+                  psfmt32[idxof((i + size - 1) % size)]);
+    psfmt32[idxof((i + mid) % size)] ^= r;
+    r -= i;
+    psfmt32[idxof((i + mid + lag) % size)] ^= r;
+    psfmt32[idxof(i)] = r;
+    i = (i + 1) % size;
+  }
+  initial_mask(dsfmt);
+  period_certification(dsfmt);
+  dsfmt->idx = DSFMT_N64;
+}
+#if defined(__INTEL_COMPILER)
+#pragma warning(default : 981)
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+extern inline double dsfmt_next_double(dsfmt_state *state);
+
+extern inline uint64_t dsfmt_next64(dsfmt_state *state);
+
+extern inline uint32_t dsfmt_next32(dsfmt_state *state);
+
+void dsfmt_jump(dsfmt_state *state) { dSFMT_jump(state->state, poly_128); };
\ No newline at end of file
diff --git a/numpy/random/src/dsfmt/dSFMT.h b/numpy/random/src/dsfmt/dSFMT.h
new file mode 100644
index 000000000..224d0108f
--- /dev/null
+++ b/numpy/random/src/dsfmt/dSFMT.h
@@ -0,0 +1,691 @@
+#pragma once
+/**
+ * @file dSFMT.h
+ *
+ * @brief double precision SIMD oriented Fast Mersenne Twister(dSFMT)
+ * pseudorandom number generator based on IEEE 754 format.
+ *
+ * @author Mutsuo Saito (Hiroshima University)
+ * @author Makoto Matsumoto (Hiroshima University)
+ *
+ * Copyright (C) 2007, 2008 Mutsuo Saito, Makoto Matsumoto and
+ * Hiroshima University. All rights reserved.
+ * Copyright (C) 2012 Mutsuo Saito, Makoto Matsumoto,
+ * Hiroshima University and The University of Tokyo.
+ * All rights reserved.
+ *
+ * The new BSD License is applied to this software.
+ * see LICENSE.txt
+ *
+ * @note We assume that your system has inttypes.h.  If your system
+ * doesn't have inttypes.h, you have to typedef uint32_t and uint64_t,
+ * and you have to define PRIu64 and PRIx64 in this file as follows:
+ * @verbatim
+ typedef unsigned int uint32_t
+ typedef unsigned long long uint64_t
+ #define PRIu64 "llu"
+ #define PRIx64 "llx"
+@endverbatim
+ * uint32_t must be exactly 32-bit unsigned integer type (no more, no
+ * less), and uint64_t must be exactly 64-bit unsigned integer type.
+ * PRIu64 and PRIx64 are used for printf function to print 64-bit
+ * unsigned int and 64-bit unsigned int in hexadecimal format.
+ */
+
+#ifndef DSFMT_H
+#define DSFMT_H
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include <assert.h>
+#include <stdio.h>
+
+#if !defined(DSFMT_MEXP)
+#ifdef __GNUC__
+#warning "DSFMT_MEXP is not defined. I assume DSFMT_MEXP is 19937."
+#endif
+#define DSFMT_MEXP 19937
+#endif
+/*-----------------
+  BASIC DEFINITIONS
+  -----------------*/
+/* Mersenne Exponent. The period of the sequence
+ *  is a multiple of 2^DSFMT_MEXP-1.
+ * #define DSFMT_MEXP 19937 */
+/** DSFMT generator has an internal state array of 128-bit integers,
+ * and N is its size. */
+#define DSFMT_N ((DSFMT_MEXP - 128) / 104 + 1)
+/** N32 is the size of internal state array when regarded as an array
+ * of 32-bit integers.*/
+#define DSFMT_N32 (DSFMT_N * 4)
+/** N64 is the size of internal state array when regarded as an array
+ * of 64-bit integers.*/
+#define DSFMT_N64 (DSFMT_N * 2)
+
+#if !defined(DSFMT_BIG_ENDIAN)
+#if defined(__BYTE_ORDER) && defined(__BIG_ENDIAN)
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define DSFMT_BIG_ENDIAN 1
+#endif
+#elif defined(_BYTE_ORDER) && defined(_BIG_ENDIAN)
+#if _BYTE_ORDER == _BIG_ENDIAN
+#define DSFMT_BIG_ENDIAN 1
+#endif
+#elif defined(__BYTE_ORDER__) && defined(__BIG_ENDIAN__)
+#if __BYTE_ORDER__ == __BIG_ENDIAN__
+#define DSFMT_BIG_ENDIAN 1
+#endif
+#elif defined(BYTE_ORDER) && defined(BIG_ENDIAN)
+#if BYTE_ORDER == BIG_ENDIAN
+#define DSFMT_BIG_ENDIAN 1
+#endif
+#elif defined(__BIG_ENDIAN) || defined(_BIG_ENDIAN) ||                         \
+    defined(__BIG_ENDIAN__) || defined(BIG_ENDIAN)
+#define DSFMT_BIG_ENDIAN 1
+#endif
+#endif
+
+#if defined(DSFMT_BIG_ENDIAN) && defined(__amd64)
+#undef DSFMT_BIG_ENDIAN
+#endif
+
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
+#include <inttypes.h>
+#elif defined(_MSC_VER) || defined(__BORLANDC__)
+#if !defined(DSFMT_UINT32_DEFINED) && !defined(SFMT_UINT32_DEFINED)
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+#ifndef UINT64_C
+#define UINT64_C(v) (v##ui64)
+#endif
+#define DSFMT_UINT32_DEFINED
+#if !defined(inline) && !defined(__cplusplus)
+#define inline __forceinline
+#endif
+#endif
+#else
+#include <inttypes.h>
+#if !defined(inline) && !defined(__cplusplus)
+#if defined(__GNUC__)
+#define inline __forceinline__
+#else
+#define inline
+#endif
+#endif
+#endif
+
+#ifndef PRIu64
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+#define PRIu64 "I64u"
+#define PRIx64 "I64x"
+#else
+#define PRIu64 "llu"
+#define PRIx64 "llx"
+#endif
+#endif
+
+#ifndef UINT64_C
+#define UINT64_C(v) (v##ULL)
+#endif
+
+/*------------------------------------------
+  128-bit SIMD like data type for standard C
+  ------------------------------------------*/
+#if defined(HAVE_ALTIVEC)
+#if !defined(__APPLE__)
+#include <altivec.h>
+#endif
+/** 128-bit data structure */
+union W128_T {
+  vector unsigned int s;
+  uint64_t u[2];
+  uint32_t u32[4];
+  double d[2];
+};
+
+#elif defined(HAVE_SSE2)
+#include <emmintrin.h>
+
+/** 128-bit data structure */
+union W128_T {
+  __m128i si;
+  __m128d sd;
+  uint64_t u[2];
+  uint32_t u32[4];
+  double d[2];
+};
+#else /* standard C */
+/** 128-bit data structure */
+union W128_T {
+  uint64_t u[2];
+  uint32_t u32[4];
+  double d[2];
+};
+#endif
+
+/** 128-bit data type */
+typedef union W128_T w128_t;
+
+/** the 128-bit internal state array */
+struct DSFMT_T {
+  w128_t status[DSFMT_N + 1];
+  int idx;
+};
+typedef struct DSFMT_T dsfmt_t;
+
+/** dsfmt internal state vector */
+extern dsfmt_t dsfmt_global_data;
+/** dsfmt mexp for check */
+extern const int dsfmt_global_mexp;
+
+void dsfmt_gen_rand_all(dsfmt_t *dsfmt);
+void dsfmt_fill_array_open_close(dsfmt_t *dsfmt, double array[], int size);
+void dsfmt_fill_array_close_open(dsfmt_t *dsfmt, double array[], int size);
+void dsfmt_fill_array_open_open(dsfmt_t *dsfmt, double array[], int size);
+void dsfmt_fill_array_close1_open2(dsfmt_t *dsfmt, double array[], int size);
+void dsfmt_chk_init_gen_rand(dsfmt_t *dsfmt, uint32_t seed, int mexp);
+void dsfmt_chk_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
+                             int key_length, int mexp);
+const char *dsfmt_get_idstring(void);
+int dsfmt_get_min_array_size(void);
+
+#if defined(__GNUC__)
+#define DSFMT_PRE_INLINE inline static
+#define DSFMT_PST_INLINE __attribute__((always_inline))
+#elif defined(_MSC_VER) && _MSC_VER >= 1200
+#define DSFMT_PRE_INLINE __forceinline static
+#define DSFMT_PST_INLINE
+#else
+#define DSFMT_PRE_INLINE inline static
+#define DSFMT_PST_INLINE
+#endif
+DSFMT_PRE_INLINE uint32_t dsfmt_genrand_uint32(dsfmt_t *dsfmt) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double
+dsfmt_genrand_close1_open2(dsfmt_t *dsfmt) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double
+dsfmt_genrand_close_open(dsfmt_t *dsfmt) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double
+dsfmt_genrand_open_close(dsfmt_t *dsfmt) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double
+dsfmt_genrand_open_open(dsfmt_t *dsfmt) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE uint32_t dsfmt_gv_genrand_uint32(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double dsfmt_gv_genrand_close1_open2(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double dsfmt_gv_genrand_close_open(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double dsfmt_gv_genrand_open_close(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double dsfmt_gv_genrand_open_open(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_gv_fill_array_open_close(double array[],
+                                                     int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_gv_fill_array_close_open(double array[],
+                                                     int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_gv_fill_array_open_open(double array[],
+                                                    int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void
+dsfmt_gv_fill_array_close1_open2(double array[], int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_gv_init_gen_rand(uint32_t seed) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_gv_init_by_array(uint32_t init_key[],
+                                             int key_length) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_init_gen_rand(dsfmt_t *dsfmt,
+                                          uint32_t seed) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void dsfmt_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
+                                          int key_length) DSFMT_PST_INLINE;
+
+/**
+ * This function generates and returns unsigned 32-bit integer.
+ * This is slower than SFMT, only for convenience usage.
+ * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
+ * before this function.
+ * @param dsfmt dsfmt internal state date
+ * @return double precision floating point pseudorandom number
+ */
+inline static uint32_t dsfmt_genrand_uint32(dsfmt_t *dsfmt) {
+  uint32_t r;
+  uint64_t *psfmt64 = &dsfmt->status[0].u[0];
+
+  if (dsfmt->idx >= DSFMT_N64) {
+    dsfmt_gen_rand_all(dsfmt);
+    dsfmt->idx = 0;
+  }
+  r = psfmt64[dsfmt->idx++] & 0xffffffffU;
+  return r;
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range [1, 2).  This is
+ * the primitive and faster than generating numbers in other ranges.
+ * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
+ * before this function.
+ * @param dsfmt dsfmt internal state date
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_genrand_close1_open2(dsfmt_t *dsfmt) {
+  double r;
+  double *psfmt64 = &dsfmt->status[0].d[0];
+
+  if (dsfmt->idx >= DSFMT_N64) {
+    dsfmt_gen_rand_all(dsfmt);
+    dsfmt->idx = 0;
+  }
+  r = psfmt64[dsfmt->idx++];
+  return r;
+}
+
+/**
+ * This function generates and returns unsigned 32-bit integer.
+ * This is slower than SFMT, only for convenience usage.
+ * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
+ * before this function.  This function uses \b global variables.
+ * @return double precision floating point pseudorandom number
+ */
+inline static uint32_t dsfmt_gv_genrand_uint32(void) {
+  return dsfmt_genrand_uint32(&dsfmt_global_data);
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range [1, 2).
+ * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
+ * before this function. This function uses \b global variables.
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_gv_genrand_close1_open2(void) {
+  return dsfmt_genrand_close1_open2(&dsfmt_global_data);
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range [0, 1).
+ * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
+ * before this function.
+ * @param dsfmt dsfmt internal state date
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_genrand_close_open(dsfmt_t *dsfmt) {
+  return dsfmt_genrand_close1_open2(dsfmt) - 1.0;
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range [0, 1).
+ * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
+ * before this function. This function uses \b global variables.
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_gv_genrand_close_open(void) {
+  return dsfmt_gv_genrand_close1_open2() - 1.0;
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range (0, 1].
+ * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
+ * before this function.
+ * @param dsfmt dsfmt internal state date
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_genrand_open_close(dsfmt_t *dsfmt) {
+  return 2.0 - dsfmt_genrand_close1_open2(dsfmt);
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range (0, 1].
+ * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
+ * before this function. This function uses \b global variables.
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_gv_genrand_open_close(void) {
+  return 2.0 - dsfmt_gv_genrand_close1_open2();
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range (0, 1).
+ * dsfmt_init_gen_rand() or dsfmt_init_by_array() must be called
+ * before this function.
+ * @param dsfmt dsfmt internal state date
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_genrand_open_open(dsfmt_t *dsfmt) {
+  double *dsfmt64 = &dsfmt->status[0].d[0];
+  union {
+    double d;
+    uint64_t u;
+  } r;
+
+  if (dsfmt->idx >= DSFMT_N64) {
+    dsfmt_gen_rand_all(dsfmt);
+    dsfmt->idx = 0;
+  }
+  r.d = dsfmt64[dsfmt->idx++];
+  r.u |= 1;
+  return r.d - 1.0;
+}
+
+/**
+ * This function generates and returns double precision pseudorandom
+ * number which distributes uniformly in the range (0, 1).
+ * dsfmt_gv_init_gen_rand() or dsfmt_gv_init_by_array() must be called
+ * before this function. This function uses \b global variables.
+ * @return double precision floating point pseudorandom number
+ */
+inline static double dsfmt_gv_genrand_open_open(void) {
+  return dsfmt_genrand_open_open(&dsfmt_global_data);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range [1, 2) to the
+ * specified array[] by one call. This function is the same as
+ * dsfmt_fill_array_close1_open2() except that this function uses
+ * \b global variables.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_fill_array_close1_open2()
+ */
+inline static void dsfmt_gv_fill_array_close1_open2(double array[], int size) {
+  dsfmt_fill_array_close1_open2(&dsfmt_global_data, array, size);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range (0, 1] to the
+ * specified array[] by one call. This function is the same as
+ * dsfmt_gv_fill_array_close1_open2() except the distribution range.
+ * This function uses \b global variables.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_fill_array_close1_open2() and \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void dsfmt_gv_fill_array_open_close(double array[], int size) {
+  dsfmt_fill_array_open_close(&dsfmt_global_data, array, size);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range [0, 1) to the
+ * specified array[] by one call. This function is the same as
+ * dsfmt_gv_fill_array_close1_open2() except the distribution range.
+ * This function uses \b global variables.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_fill_array_close1_open2() \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void dsfmt_gv_fill_array_close_open(double array[], int size) {
+  dsfmt_fill_array_close_open(&dsfmt_global_data, array, size);
+}
+
+/**
+ * This function generates double precision floating point
+ * pseudorandom numbers which distribute in the range (0, 1) to the
+ * specified array[] by one call. This function is the same as
+ * dsfmt_gv_fill_array_close1_open2() except the distribution range.
+ * This function uses \b global variables.
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_fill_array_close1_open2() \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void dsfmt_gv_fill_array_open_open(double array[], int size) {
+  dsfmt_fill_array_open_open(&dsfmt_global_data, array, size);
+}
+
+/**
+ * This function initializes the internal state array with a 32-bit
+ * integer seed.
+ * @param dsfmt dsfmt state vector.
+ * @param seed a 32-bit integer used as the seed.
+ */
+inline static void dsfmt_init_gen_rand(dsfmt_t *dsfmt, uint32_t seed) {
+  dsfmt_chk_init_gen_rand(dsfmt, seed, DSFMT_MEXP);
+}
+
+/**
+ * This function initializes the internal state array with a 32-bit
+ * integer seed. This function uses \b global variables.
+ * @param seed a 32-bit integer used as the seed.
+ * see also \sa dsfmt_init_gen_rand()
+ */
+inline static void dsfmt_gv_init_gen_rand(uint32_t seed) {
+  dsfmt_init_gen_rand(&dsfmt_global_data, seed);
+}
+
+/**
+ * This function initializes the internal state array,
+ * with an array of 32-bit integers used as the seeds.
+ * @param dsfmt dsfmt state vector
+ * @param init_key the array of 32-bit integers, used as a seed.
+ * @param key_length the length of init_key.
+ */
+inline static void dsfmt_init_by_array(dsfmt_t *dsfmt, uint32_t init_key[],
+                                       int key_length) {
+  dsfmt_chk_init_by_array(dsfmt, init_key, key_length, DSFMT_MEXP);
+}
+
+/**
+ * This function initializes the internal state array,
+ * with an array of 32-bit integers used as the seeds.
+ * This function uses \b global variables.
+ * @param init_key the array of 32-bit integers, used as a seed.
+ * @param key_length the length of init_key.
+ * see also \sa dsfmt_init_by_array()
+ */
+inline static void dsfmt_gv_init_by_array(uint32_t init_key[], int key_length) {
+  dsfmt_init_by_array(&dsfmt_global_data, init_key, key_length);
+}
+
+#if !defined(DSFMT_DO_NOT_USE_OLD_NAMES)
+DSFMT_PRE_INLINE const char *get_idstring(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE int get_min_array_size(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void init_gen_rand(uint32_t seed) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void init_by_array(uint32_t init_key[],
+                                    int key_length) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double genrand_close1_open2(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double genrand_close_open(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double genrand_open_close(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE double genrand_open_open(void) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void fill_array_open_close(double array[],
+                                            int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void fill_array_close_open(double array[],
+                                            int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void fill_array_open_open(double array[],
+                                           int size) DSFMT_PST_INLINE;
+DSFMT_PRE_INLINE void fill_array_close1_open2(double array[],
+                                              int size) DSFMT_PST_INLINE;
+
+/**
+ * This function is just the same as dsfmt_get_idstring().
+ * @return id string.
+ * see also \sa dsfmt_get_idstring()
+ */
+inline static const char *get_idstring(void) { return dsfmt_get_idstring(); }
+
+/**
+ * This function is just the same as dsfmt_get_min_array_size().
+ * @return minimum size of array used for fill_array functions.
+ * see also \sa dsfmt_get_min_array_size()
+ */
+inline static int get_min_array_size(void) {
+  return dsfmt_get_min_array_size();
+}
+
+/**
+ * This function is just the same as dsfmt_gv_init_gen_rand().
+ * @param seed a 32-bit integer used as the seed.
+ * see also \sa dsfmt_gv_init_gen_rand(), \sa dsfmt_init_gen_rand().
+ */
+inline static void init_gen_rand(uint32_t seed) {
+  dsfmt_gv_init_gen_rand(seed);
+}
+
+/**
+ * This function is just the same as dsfmt_gv_init_by_array().
+ * @param init_key the array of 32-bit integers, used as a seed.
+ * @param key_length the length of init_key.
+ * see also \sa dsfmt_gv_init_by_array(), \sa dsfmt_init_by_array().
+ */
+inline static void init_by_array(uint32_t init_key[], int key_length) {
+  dsfmt_gv_init_by_array(init_key, key_length);
+}
+
+/**
+ * This function is just the same as dsfmt_gv_genrand_close1_open2().
+ * @return double precision floating point number.
+ * see also \sa dsfmt_genrand_close1_open2() \sa
+ * dsfmt_gv_genrand_close1_open2()
+ */
+inline static double genrand_close1_open2(void) {
+  return dsfmt_gv_genrand_close1_open2();
+}
+
+/**
+ * This function is just the same as dsfmt_gv_genrand_close_open().
+ * @return double precision floating point number.
+ * see also \sa dsfmt_genrand_close_open() \sa
+ * dsfmt_gv_genrand_close_open()
+ */
+inline static double genrand_close_open(void) {
+  return dsfmt_gv_genrand_close_open();
+}
+
+/**
+ * This function is just the same as dsfmt_gv_genrand_open_close().
+ * @return double precision floating point number.
+ * see also \sa dsfmt_genrand_open_close() \sa
+ * dsfmt_gv_genrand_open_close()
+ */
+inline static double genrand_open_close(void) {
+  return dsfmt_gv_genrand_open_close();
+}
+
+/**
+ * This function is just the same as dsfmt_gv_genrand_open_open().
+ * @return double precision floating point number.
+ * see also \sa dsfmt_genrand_open_open() \sa
+ * dsfmt_gv_genrand_open_open()
+ */
+inline static double genrand_open_open(void) {
+  return dsfmt_gv_genrand_open_open();
+}
+
+/**
+ * This function is juset the same as dsfmt_gv_fill_array_open_close().
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_gv_fill_array_open_close(), \sa
+ * dsfmt_fill_array_close1_open2(), \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void fill_array_open_close(double array[], int size) {
+  dsfmt_gv_fill_array_open_close(array, size);
+}
+
+/**
+ * This function is juset the same as dsfmt_gv_fill_array_close_open().
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_gv_fill_array_close_open(), \sa
+ * dsfmt_fill_array_close1_open2(), \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void fill_array_close_open(double array[], int size) {
+  dsfmt_gv_fill_array_close_open(array, size);
+}
+
+/**
+ * This function is juset the same as dsfmt_gv_fill_array_open_open().
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_gv_fill_array_open_open(), \sa
+ * dsfmt_fill_array_close1_open2(), \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void fill_array_open_open(double array[], int size) {
+  dsfmt_gv_fill_array_open_open(array, size);
+}
+
+/**
+ * This function is juset the same as dsfmt_gv_fill_array_close1_open2().
+ * @param array an array where pseudorandom numbers are filled
+ * by this function.
+ * @param size the number of pseudorandom numbers to be generated.
+ * see also \sa dsfmt_fill_array_close1_open2(), \sa
+ * dsfmt_gv_fill_array_close1_open2()
+ */
+inline static void fill_array_close1_open2(double array[], int size) {
+  dsfmt_gv_fill_array_close1_open2(array, size);
+}
+#endif /* DSFMT_DO_NOT_USE_OLD_NAMES */
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* DSFMT_H */
+
+union random_val_t {
+  double d;
+  uint64_t u64;
+};
+
+typedef struct s_dsfmt_state {
+  dsfmt_t *state;
+  int has_uint32;
+  uint32_t uinteger;
+
+  double *buffered_uniforms;
+  int buffer_loc;
+} dsfmt_state;
+
+static inline double dsfmt_next_buffer(dsfmt_state *state) {
+  if (state->buffer_loc < DSFMT_N64) {
+    double out = state->buffered_uniforms[state->buffer_loc];
+    state->buffer_loc++;
+    return out;
+  }
+  dsfmt_fill_array_close1_open2(state->state, state->buffered_uniforms,
+                                DSFMT_N64);
+  state->buffer_loc = 1;
+  return state->buffered_uniforms[0];
+}
+
+static inline double dsfmt_next_double(dsfmt_state *state) {
+  return dsfmt_next_buffer(state) - 1.0;
+}
+
+static inline uint64_t dsfmt_next64(dsfmt_state *state) {
+  /* Discard bottom 16 bits */
+  uint64_t out;
+  union random_val_t rv;
+  rv.d = dsfmt_next_buffer(state);
+  out = (rv.u64 >> 16) << 32;
+  rv.d = dsfmt_next_buffer(state);
+  out |= (rv.u64 >> 16) & 0xffffffff;
+  return out;
+}
+
+static inline uint32_t dsfmt_next32(dsfmt_state *state) {
+  /* Discard bottom 16 bits */
+  union random_val_t rv;
+  rv.d = dsfmt_next_buffer(state);
+  // uint64_t *out = (uint64_t *)&d;
+  return (uint32_t)((rv.u64 >> 16) & 0xffffffff);
+}
+
+static inline uint64_t dsfmt_next_raw(dsfmt_state *state) {
+  union random_val_t rv;
+  rv.d = dsfmt_next_buffer(state);
+  return rv.u64;
+}
+
+void dsfmt_jump(dsfmt_state *state);
\ No newline at end of file
diff --git a/numpy/random/src/entropy/LICENSE.md b/numpy/random/src/entropy/LICENSE.md
new file mode 100644
index 000000000..b7276aad7
--- /dev/null
+++ b/numpy/random/src/entropy/LICENSE.md
@@ -0,0 +1,25 @@
+# ENTROPY
+
+_Parts of this module were derived from PCG_
+
+
+PCG Random Number Generation for C.
+
+Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+For additional information about the PCG random number generation scheme,
+including its license and other licensing options, visit
+
+ http://www.pcg-random.org
diff --git a/numpy/random/src/entropy/entropy.c b/numpy/random/src/entropy/entropy.c
new file mode 100644
index 000000000..ead4bef83
--- /dev/null
+++ b/numpy/random/src/entropy/entropy.c
@@ -0,0 +1,174 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+/* This code provides a mechanism for getting external randomness for
+ * seeding purposes.  Usually, it's just a wrapper around reading
+ * /dev/random.
+ *
+ * Alas, because not every system provides /dev/random, we need a fallback.
+ * We also need to try to test whether or not to use the fallback.
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "entropy.h"
+#ifdef _WIN32
+/* Windows */
+#include <sys/timeb.h>
+#include <time.h>
+#include <windows.h>
+
+#include <wincrypt.h>
+#else
+/* Unix */
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#endif
+
+#ifndef IS_UNIX
+#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) ||               \
+                         (defined(__APPLE__) && defined(__MACH__)))
+#define IS_UNIX 1
+#else
+#define IS_UNIX 0
+#endif
+#endif
+
+// If HAVE_DEV_RANDOM is set, we use that value, otherwise we guess
+#ifndef HAVE_DEV_RANDOM
+#define HAVE_DEV_RANDOM IS_UNIX
+#endif
+
+#if HAVE_DEV_RANDOM
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+#if HAVE_DEV_RANDOM
+/* entropy_getbytes(dest, size):
+ *     Use /dev/random to get some external entropy for seeding purposes.
+ *
+ * Note:
+ *     If reading /dev/random fails (which ought to never happen), it returns
+ *     false, otherwise it returns true.  If it fails, you could instead call
+ *     fallback_entropy_getbytes which always succeeds.
+ */
+
+bool entropy_getbytes(void *dest, size_t size) {
+  int fd = open("/dev/urandom", O_RDONLY);
+  if (fd < 0)
+    return false;
+  ssize_t sz = read(fd, dest, size);
+  if ((sz < 0) || ((size_t)sz < size))
+    return false;
+  return close(fd) == 0;
+}
+#endif
+
+#ifdef _WIN32
+bool entropy_getbytes(void *dest, size_t size) {
+  HCRYPTPROV hCryptProv;
+  BOOL done;
+
+  if (!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
+                           CRYPT_VERIFYCONTEXT) ||
+      !hCryptProv) {
+    return true;
+  }
+  done = CryptGenRandom(hCryptProv, (DWORD)size, (unsigned char *)dest);
+  CryptReleaseContext(hCryptProv, 0);
+  if (!done) {
+    return false;
+  }
+
+  return true;
+}
+#endif
+
+/* Thomas Wang 32/64 bits integer hash function */
+uint32_t entropy_hash_32(uint32_t key) {
+  key += ~(key << 15);
+  key ^= (key >> 10);
+  key += (key << 3);
+  key ^= (key >> 6);
+  key += ~(key << 11);
+  key ^= (key >> 16);
+  return key;
+}
+
+uint64_t entropy_hash_64(uint64_t key) {
+  key = (~key) + (key << 21); // key = (key << 21) - key - 1;
+  key = key ^ (key >> 24);
+  key = (key + (key << 3)) + (key << 8); // key * 265
+  key = key ^ (key >> 14);
+  key = (key + (key << 2)) + (key << 4); // key * 21
+  key = key ^ (key >> 28);
+  key = key + (key << 31);
+  return key;
+}
+
+uint32_t entropy_randombytes(void) {
+
+#ifndef _WIN32
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return entropy_hash_32(getpid()) ^ entropy_hash_32(tv.tv_sec) ^
+         entropy_hash_32(tv.tv_usec) ^ entropy_hash_32(clock());
+#else
+  uint32_t out = 0;
+  int64_t counter;
+  struct _timeb tv;
+  _ftime_s(&tv);
+  out = entropy_hash_32(GetCurrentProcessId()) ^
+        entropy_hash_32((uint32_t)tv.time) ^ entropy_hash_32(tv.millitm) ^
+        entropy_hash_32(clock());
+  if (QueryPerformanceCounter((LARGE_INTEGER *)&counter) != 0)
+    out ^= entropy_hash_32((uint32_t)(counter & 0xffffffff));
+  return out;
+#endif
+}
+
+bool entropy_fallback_getbytes(void *dest, size_t size) {
+  int hashes = (int)size;
+  uint32_t *hash = malloc(hashes * sizeof(uint32_t));
+  // uint32_t hash[hashes];
+  int i;
+  for (i = 0; i < hashes; i++) {
+    hash[i] = entropy_randombytes();
+  }
+  memcpy(dest, (void *)hash, size);
+  free(hash);
+  return true;
+}
+
+void entropy_fill(void *dest, size_t size) {
+  bool success;
+  success = entropy_getbytes(dest, size);
+  if (!success) {
+    entropy_fallback_getbytes(dest, size);
+  }
+}
diff --git a/numpy/random/src/entropy/entropy.h b/numpy/random/src/entropy/entropy.h
new file mode 100644
index 000000000..785603dd3
--- /dev/null
+++ b/numpy/random/src/entropy/entropy.h
@@ -0,0 +1,48 @@
+#ifndef _RANDOMDGEN__ENTROPY_H_
+#define _RANDOMDGEN__ENTROPY_H_
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+#include <stddef.h>
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/stdint.h"
+typedef int bool;
+#define false 0
+#define true 1
+#else
+#include <stdbool.h>
+#include <stdint.h>
+#endif
+#else
+#include <stdbool.h>
+#include <stdint.h>
+#endif
+
+extern void entropy_fill(void *dest, size_t size);
+
+extern bool entropy_getbytes(void *dest, size_t size);
+
+extern bool entropy_fallback_getbytes(void *dest, size_t size);
+
+#endif
diff --git a/numpy/random/src/legacy/LICENSE.md b/numpy/random/src/legacy/LICENSE.md
new file mode 100644
index 000000000..88b1791b2
--- /dev/null
+++ b/numpy/random/src/legacy/LICENSE.md
@@ -0,0 +1,30 @@
+Copyright (c) 2005-2017, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+
+* Neither the name of the NumPy Developers nor the names of any
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/numpy/random/src/legacy/distributions-boxmuller.c b/numpy/random/src/legacy/distributions-boxmuller.c
new file mode 100644
index 000000000..5d3ba27f8
--- /dev/null
+++ b/numpy/random/src/legacy/distributions-boxmuller.c
@@ -0,0 +1,214 @@
+#include "distributions-boxmuller.h"
+
+static NPY_INLINE double legacy_double(aug_brng_t *aug_state) {
+  return aug_state->basicrng->next_double(aug_state->basicrng->state);
+}
+
+double legacy_gauss(aug_brng_t *aug_state) {
+  if (aug_state->has_gauss) {
+    const double temp = aug_state->gauss;
+    aug_state->has_gauss = false;
+    aug_state->gauss = 0.0;
+    return temp;
+  } else {
+    double f, x1, x2, r2;
+
+    do {
+      x1 = 2.0 * legacy_double(aug_state) - 1.0;
+      x2 = 2.0 * legacy_double(aug_state) - 1.0;
+      r2 = x1 * x1 + x2 * x2;
+    } while (r2 >= 1.0 || r2 == 0.0);
+
+    /* Polar method, a more efficient version of the Box-Muller approach. */
+    f = sqrt(-2.0 * log(r2) / r2);
+    /* Keep for next call */
+    aug_state->gauss = f * x1;
+    aug_state->has_gauss = true;
+    return f * x2;
+  }
+}
+
+double legacy_standard_exponential(aug_brng_t *aug_state) {
+  /* We use -log(1-U) since U is [0, 1) */
+  return -log(1.0 - legacy_double(aug_state));
+}
+
+double legacy_standard_gamma(aug_brng_t *aug_state, double shape) {
+  double b, c;
+  double U, V, X, Y;
+
+  if (shape == 1.0) {
+    return legacy_standard_exponential(aug_state);
+  }
+  else if (shape == 0.0) {
+    return 0.0;
+  } else if (shape < 1.0) {
+    for (;;) {
+      U = legacy_double(aug_state);
+      V = legacy_standard_exponential(aug_state);
+      if (U <= 1.0 - shape) {
+        X = pow(U, 1. / shape);
+        if (X <= V) {
+          return X;
+        }
+      } else {
+        Y = -log((1 - U) / shape);
+        X = pow(1.0 - shape + shape * Y, 1. / shape);
+        if (X <= (V + Y)) {
+          return X;
+        }
+      }
+    }
+  } else {
+    b = shape - 1. / 3.;
+    c = 1. / sqrt(9 * b);
+    for (;;) {
+      do {
+        X = legacy_gauss(aug_state);
+        V = 1.0 + c * X;
+      } while (V <= 0.0);
+
+      V = V * V * V;
+      U = legacy_double(aug_state);
+      if (U < 1.0 - 0.0331 * (X * X) * (X * X))
+        return (b * V);
+      if (log(U) < 0.5 * X * X + b * (1. - V + log(V)))
+        return (b * V);
+    }
+  }
+}
+
+double legacy_gamma(aug_brng_t *aug_state, double shape, double scale) {
+  return scale * legacy_standard_gamma(aug_state, shape);
+}
+
+double legacy_pareto(aug_brng_t *aug_state, double a) {
+  return exp(legacy_standard_exponential(aug_state) / a) - 1;
+}
+
+double legacy_weibull(aug_brng_t *aug_state, double a) {
+  if (a == 0.0) {
+    return 0.0;
+  }
+  return pow(legacy_standard_exponential(aug_state), 1. / a);
+}
+
+double legacy_power(aug_brng_t *aug_state, double a) {
+  return pow(1 - exp(-legacy_standard_exponential(aug_state)), 1. / a);
+}
+
+double legacy_chisquare(aug_brng_t *aug_state, double df) {
+  return 2.0 * legacy_standard_gamma(aug_state, df / 2.0);
+}
+
+double legacy_noncentral_chisquare(aug_brng_t *aug_state, double df,
+                                   double nonc) {
+  double out;
+  if (nonc == 0) {
+    return legacy_chisquare(aug_state, df);
+  }
+  if (1 < df) {
+    const double Chi2 = legacy_chisquare(aug_state, df - 1);
+    const double n = legacy_gauss(aug_state) + sqrt(nonc);
+    return Chi2 + n * n;
+  } else {
+    const long i = random_poisson(aug_state->basicrng, nonc / 2.0);
+    out = legacy_chisquare(aug_state, df + 2 * i);
+    /* Insert nan guard here to avoid changing the stream */
+    if (npy_isnan(nonc)){
+      return NPY_NAN;
+    } else {
+    return out;
+    }
+  }
+}
+
+double legacy_noncentral_f(aug_brng_t *aug_state, double dfnum, double dfden,
+                           double nonc) {
+  double t = legacy_noncentral_chisquare(aug_state, dfnum, nonc) * dfden;
+  return t / (legacy_chisquare(aug_state, dfden) * dfnum);
+}
+
+double legacy_wald(aug_brng_t *aug_state, double mean, double scale) {
+  double U, X, Y;
+  double mu_2l;
+
+  mu_2l = mean / (2 * scale);
+  Y = legacy_gauss(aug_state);
+  Y = mean * Y * Y;
+  X = mean + mu_2l * (Y - sqrt(4 * scale * Y + Y * Y));
+  U = legacy_double(aug_state);
+  if (U <= mean / (mean + X)) {
+    return X;
+  } else {
+    return mean * mean / X;
+  }
+}
+
+double legacy_normal(aug_brng_t *aug_state, double loc, double scale) {
+  return loc + scale * legacy_gauss(aug_state);
+}
+
+double legacy_lognormal(aug_brng_t *aug_state, double mean, double sigma) {
+  return exp(legacy_normal(aug_state, mean, sigma));
+}
+
+double legacy_standard_t(aug_brng_t *aug_state, double df) {
+  double num, denom;
+
+  num = legacy_gauss(aug_state);
+  denom = legacy_standard_gamma(aug_state, df / 2);
+  return sqrt(df / 2) * num / sqrt(denom);
+}
+
+int64_t legacy_negative_binomial(aug_brng_t *aug_state, double n, double p) {
+  double Y = legacy_gamma(aug_state, n, (1 - p) / p);
+  return random_poisson(aug_state->basicrng, Y);
+}
+
+double legacy_standard_cauchy(aug_brng_t *aug_state) {
+  return legacy_gauss(aug_state) / legacy_gauss(aug_state);
+}
+
+double legacy_beta(aug_brng_t *aug_state, double a, double b) {
+  double Ga, Gb;
+
+  if ((a <= 1.0) && (b <= 1.0)) {
+    double U, V, X, Y;
+    /* Use Johnk's algorithm */
+
+    while (1) {
+      U = legacy_double(aug_state);
+      V = legacy_double(aug_state);
+      X = pow(U, 1.0 / a);
+      Y = pow(V, 1.0 / b);
+
+      if ((X + Y) <= 1.0) {
+        if (X + Y > 0) {
+          return X / (X + Y);
+        } else {
+          double logX = log(U) / a;
+          double logY = log(V) / b;
+          double logM = logX > logY ? logX : logY;
+          logX -= logM;
+          logY -= logM;
+
+          return exp(logX - log(exp(logX) + exp(logY)));
+        }
+      }
+    }
+  } else {
+    Ga = legacy_standard_gamma(aug_state, a);
+    Gb = legacy_standard_gamma(aug_state, b);
+    return Ga / (Ga + Gb);
+  }
+}
+
+double legacy_f(aug_brng_t *aug_state, double dfnum, double dfden) {
+  return ((legacy_chisquare(aug_state, dfnum) * dfden) /
+          (legacy_chisquare(aug_state, dfden) * dfnum));
+}
+
+double legacy_exponential(aug_brng_t *aug_state, double scale) {
+  return scale * legacy_standard_exponential(aug_state);
+}
diff --git a/numpy/random/src/legacy/distributions-boxmuller.h b/numpy/random/src/legacy/distributions-boxmuller.h
new file mode 100644
index 000000000..445686e6c
--- /dev/null
+++ b/numpy/random/src/legacy/distributions-boxmuller.h
@@ -0,0 +1,40 @@
+#ifndef _RANDOMDGEN__DISTRIBUTIONS_LEGACY_H_
+#define _RANDOMDGEN__DISTRIBUTIONS_LEGACY_H_
+
+
+#include "../distributions/distributions.h"
+
+typedef struct aug_brng {
+  brng_t *basicrng;
+  int has_gauss;
+  double gauss;
+} aug_brng_t;
+
+extern double legacy_gauss(aug_brng_t *aug_state);
+extern double legacy_standard_exponential(aug_brng_t *aug_state);
+extern double legacy_pareto(aug_brng_t *aug_state, double a);
+extern double legacy_weibull(aug_brng_t *aug_state, double a);
+extern double legacy_power(aug_brng_t *aug_state, double a);
+extern double legacy_gamma(aug_brng_t *aug_state, double shape, double scale);
+extern double legacy_pareto(aug_brng_t *aug_state, double a);
+extern double legacy_weibull(aug_brng_t *aug_state, double a);
+extern double legacy_chisquare(aug_brng_t *aug_state, double df);
+extern double legacy_noncentral_chisquare(aug_brng_t *aug_state, double df,
+                                          double nonc);
+
+extern double legacy_noncentral_f(aug_brng_t *aug_state, double dfnum,
+                                  double dfden, double nonc);
+extern double legacy_wald(aug_brng_t *aug_state, double mean, double scale);
+extern double legacy_lognormal(aug_brng_t *aug_state, double mean,
+                               double sigma);
+extern double legacy_standard_t(aug_brng_t *aug_state, double df);
+extern int64_t legacy_negative_binomial(aug_brng_t *aug_state, double n,
+                                        double p);
+extern double legacy_standard_cauchy(aug_brng_t *state);
+extern double legacy_beta(aug_brng_t *aug_state, double a, double b);
+extern double legacy_f(aug_brng_t *aug_state, double dfnum, double dfden);
+extern double legacy_normal(aug_brng_t *aug_state, double loc, double scale);
+extern double legacy_standard_gamma(aug_brng_t *aug_state, double shape);
+extern double legacy_exponential(aug_brng_t *aug_state, double scale);
+
+#endif
diff --git a/numpy/random/src/mt19937/LICENSE.md b/numpy/random/src/mt19937/LICENSE.md
new file mode 100644
index 000000000..f65c3d46e
--- /dev/null
+++ b/numpy/random/src/mt19937/LICENSE.md
@@ -0,0 +1,61 @@
+# MT19937
+
+Copyright (c) 2003-2005, Jean-Sebastien Roy (js@jeannot.org)
+
+The rk_random and rk_seed functions algorithms and the original design of
+the Mersenne Twister RNG:
+
+  Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions
+  are met:
+
+  1. Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+  3. The names of its contributors may not be used to endorse or promote
+  products derived from this software without specific prior written
+  permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Original algorithm for the implementation of rk_interval function from
+Richard J. Wagner's implementation of the Mersenne Twister RNG, optimised by
+Magnus Jonsson.
+
+Constants used in the rk_double implementation by Isaku Wada.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/numpy/random/src/mt19937/mt19937-benchmark.c b/numpy/random/src/mt19937/mt19937-benchmark.c
new file mode 100644
index 000000000..039f8030a
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937-benchmark.c
@@ -0,0 +1,31 @@
+/*
+ * cl mt19937-benchmark.c mt19937.c /Ox
+ * Measure-Command { .\mt19937-benchmark.exe }
+ *
+ * gcc mt19937-benchmark.c mt19937.c -O3 -o mt19937-benchmark
+ * time ./mt19937-benchmark
+ */
+#include "mt19937.h"
+#include <inttypes.h>
+#include <stdio.h>
+#include <time.h>
+
+#define Q 1000000000
+
+int main() {
+  int i;
+  uint32_t seed = 0x0;
+  uint64_t sum = 0, count = 0;
+  mt19937_state state;
+  mt19937_seed(&state, seed);
+  clock_t begin = clock();
+  for (i = 0; i < Q; i++) {
+    sum += mt19937_next64(&state);
+    count++;
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(Q / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/mt19937/mt19937-jump.c b/numpy/random/src/mt19937/mt19937-jump.c
new file mode 100644
index 000000000..46b28cf96
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937-jump.c
@@ -0,0 +1,224 @@
+#include "mt19937-jump.h"
+#include "mt19937.h"
+
+/* 32-bits function */
+/* return the i-th coefficient of the polynomial pf */
+unsigned long get_coef(unsigned long *pf, unsigned int deg) {
+  if ((pf[deg >> 5] & (LSB << (deg & 0x1ful))) != 0)
+    return (1);
+  else
+    return (0);
+}
+
+/* 32-bit function */
+/* set the coefficient of the polynomial pf with v */
+void set_coef(unsigned long *pf, unsigned int deg, unsigned long v) {
+  if (v != 0)
+    pf[deg >> 5] ^= (LSB << (deg & 0x1ful));
+  else
+    ;
+}
+
+void gray_code(unsigned long *h) {
+  unsigned int i, j = 1, l = 1, term = LL;
+
+  h[0] = 0;
+
+  for (i = 1; i <= QQ; i++) {
+    l = (l << 1);
+    term = (term >> 1);
+    for (; j < l; j++)
+      h[j] = h[l - j - 1] ^ term;
+  }
+}
+
+void copy_state(mt19937_state *target_state, mt19937_state *state) {
+  int i;
+
+  for (i = 0; i < N; i++)
+    target_state->key[i] = state->key[i];
+
+  target_state->pos = state->pos;
+}
+
+/* next state generating function */
+void gen_next(mt19937_state *state) {
+  int num;
+  unsigned long y;
+  static unsigned long mag02[2] = {0x0ul, MATRIX_A};
+
+  num = state->pos;
+  if (num < N - M) {
+    y = (state->key[num] & UPPER_MASK) | (state->key[num + 1] & LOWER_MASK);
+    state->key[num] = state->key[num + M] ^ (y >> 1) ^ mag02[y % 2];
+    state->pos++;
+  } else if (num < N - 1) {
+    y = (state->key[num] & UPPER_MASK) | (state->key[num + 1] & LOWER_MASK);
+    state->key[num] = state->key[num + (M - N)] ^ (y >> 1) ^ mag02[y % 2];
+    state->pos++;
+  } else if (num == N - 1) {
+    y = (state->key[N - 1] & UPPER_MASK) | (state->key[0] & LOWER_MASK);
+    state->key[N - 1] = state->key[M - 1] ^ (y >> 1) ^ mag02[y % 2];
+    state->pos = 0;
+  }
+}
+
+void add_state(mt19937_state *state1, mt19937_state *state2) {
+  int i, pt1 = state1->pos, pt2 = state2->pos;
+
+  if (pt2 - pt1 >= 0) {
+    for (i = 0; i < N - pt2; i++)
+      state1->key[i + pt1] ^= state2->key[i + pt2];
+    for (; i < N - pt1; i++)
+      state1->key[i + pt1] ^= state2->key[i + (pt2 - N)];
+    for (; i < N; i++)
+      state1->key[i + (pt1 - N)] ^= state2->key[i + (pt2 - N)];
+  } else {
+    for (i = 0; i < N - pt1; i++)
+      state1->key[i + pt1] ^= state2->key[i + pt2];
+    for (; i < N - pt2; i++)
+      state1->key[i + (pt1 - N)] ^= state2->key[i + pt2];
+    for (; i < N; i++)
+      state1->key[i + (pt1 - N)] ^= state2->key[i + (pt2 - N)];
+  }
+}
+
+/*
+void gen_vec_h(mt19937_state *state, mt19937_state *vec_h,
+               unsigned long *h) {
+  int i;
+  unsigned long k, g;
+  mt19937_state v;
+
+  gray_code(h);
+
+  copy_state(&vec_h[0], state);
+
+  for (i = 0; i < QQ; i++)
+    gen_next(&vec_h[0]);
+
+  for (i = 1; i < LL; i++) {
+    copy_state(&v, state);
+    g = h[i] ^ h[i - 1];
+    for (k = 1; k < g; k = (k << 1))
+      gen_next(&v);
+    copy_state(&vec_h[h[i]], &vec_h[h[i - 1]]);
+    add_state(&vec_h[h[i]], &v);
+  }
+}
+*/
+
+/* compute pf(ss) using Sliding window algorithm */
+/*
+void calc_state(unsigned long *pf, mt19937_state *state,
+                mt19937_state *vec_h) {
+  mt19937_state *temp1;
+  int i = MEXP - 1, j, digit, skip = 0;
+
+  temp1 = (mt19937_state *)calloc(1, sizeof(mt19937_state));
+
+  while (get_coef(pf, i) == 0)
+    i--;
+
+  for (; i >= QQ; i--) {
+    if (get_coef(pf, i) != 0) {
+      for (j = 0; j < QQ + 1; j++)
+        gen_next(temp1);
+      digit = 0;
+      for (j = 0; j < QQ; j++)
+        digit = (digit << 1) ^ get_coef(pf, i - j - 1);
+      add_state(temp1, &vec_h[digit]);
+      i -= QQ;
+    } else
+      gen_next(temp1);
+  }
+
+  for (; i > -1; i--) {
+    gen_next(temp1);
+    if (get_coef(pf, i) == 1)
+      add_state(temp1, state);
+    else
+      ;
+  }
+
+  copy_state(state, temp1);
+  free(temp1);
+}
+*/
+
+/* compute pf(ss) using standard Horner method */
+void horner1(unsigned long *pf, mt19937_state *state) {
+  int i = MEXP - 1;
+  mt19937_state *temp;
+
+  temp = (mt19937_state *)calloc(1, sizeof(mt19937_state));
+
+  while (get_coef(pf, i) == 0)
+    i--;
+
+  if (i > 0) {
+    copy_state(temp, state);
+    gen_next(temp);
+    i--;
+    for (; i > 0; i--) {
+      if (get_coef(pf, i) != 0)
+        add_state(temp, state);
+      else
+        ;
+      gen_next(temp);
+    }
+    if (get_coef(pf, 0) != 0)
+      add_state(temp, state);
+    else
+      ;
+  } else if (i == 0)
+    copy_state(temp, state);
+  else
+    ;
+
+  copy_state(state, temp);
+  free(temp);
+}
+
+void mt19937_jump_state(mt19937_state *state, const char *jump_str) {
+  unsigned long *pf;
+  int i;
+
+  pf = (unsigned long *)calloc(P_SIZE, sizeof(unsigned long));
+
+  for (i = MEXP - 1; i > -1; i--) {
+    if (jump_str[i] == '1')
+      set_coef(pf, i, 1);
+  }
+  /* TODO: Should generate the next set and start from 0, but doesn't matter ??
+   */
+  if (state->pos >= N) {
+    state->pos = 0;
+  }
+
+  horner1(pf, state);
+
+  free(pf);
+}
+/*
+void mt19937_jump(mt19937_state *state, const char *jump_str)
+{
+    unsigned long h[LL];
+    mt19937_state vec_h[LL];
+    unsigned long *pf;
+    int i;
+
+    pf = (unsigned long *)calloc(P_SIZE, sizeof(unsigned long));
+
+    for (i = MEXP - 1; i > -1; i--)
+    {
+        if (jump_str[i] == '1')
+            set_coef(pf, i, 1);
+    }
+
+    gen_vec_h(state, &vec_h, &h);
+    calc_state(pf, state, &vec_h);
+
+    free(pf);
+}
+*/
\ No newline at end of file
diff --git a/numpy/random/src/mt19937/mt19937-jump.h b/numpy/random/src/mt19937/mt19937-jump.h
new file mode 100644
index 000000000..394c150a0
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937-jump.h
@@ -0,0 +1,15 @@
+#pragma once
+#include "mt19937.h"
+#include <stdlib.h>
+
+/* parameters for computing Jump */
+#define W_SIZE 32 /* size of unsigned long */
+#define MEXP 19937
+#define P_SIZE ((MEXP / W_SIZE) + 1)
+#define LSB 0x00000001UL
+#define QQ 7
+#define LL 128 /* LL = 2^(QQ) */
+
+void mt19937_jump_state(mt19937_state *state, const char *jump_str);
+
+void set_coef(unsigned long *pf, unsigned int deg, unsigned long v);
\ No newline at end of file
diff --git a/numpy/random/src/mt19937/mt19937-poly.h b/numpy/random/src/mt19937/mt19937-poly.h
new file mode 100644
index 000000000..b03747881
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937-poly.h
@@ -0,0 +1,207 @@
+static const char * poly =
+"0001000111110111011100100010101111000000010100100101000001110111100010101000110100101001011001010"
+"1110101101100101011100101101011001110011100011110100001000001011100101100010100000010011101110011"
+"0100001001111010000100100101001011100111101101001100000111001000011101100100010000001111110100010"
+"0000111101000101000101101111001011000011001001001011010011001000001000011100100010110101111111101"
+"0010001001100010011011101111101110111010111000010000011010110011111101100000100100101001010000001"
+"1001111000011010011101001101011000111001110010110000011000110101111010110011011000001110110010001"
+"1001101011011101000011001011111111100011001010111100000001111011111101000101000011000011111100101"
+"0100001111101010101100000110100110010010101011011100110011000101100101011110010101110000101011100"
+"0001010100010110100000111001100000011101011001101000001000101101010100010101100000100011110110011"
+"0101100110111101010111100010100110100011111011100111000001110110010000000100000110101010111001111"
+"0011110010000110101101010001110010100111111111100100101010010011101111011000010111101001110110110"
+"1011101101101100110111000100101100111001011111110101001000011111010011000111110011100100001101111"
+"1001010110110001000100001001000010000000001011011100101010010100011000110101001000010101100111101"
+"0011110101100110111100000111001011011001100101111011000101001011011111110110100010001100101001100"
+"1111110011111111110111011011100011000100110011011011011001101011100110010001111100001111100100001"
+"1000100011001010100101010100111110001100111111011111100100011110011101101000110100101110010111111"
+"1001010110000101001110010110001011011010101111111001110001100100011001000010111001011011000111100"
+"1101001011110111111010011000110100001010000000101010101001111101111110101111110101110101010010100"
+"1100100101010110011111001101100110001011000101010001000110011011111101111110001100000010110110101"
+"1111110100001011101011101110111101100001111000011100000110110100100100100101011000111000100110001"
+"0110110001001000111110101111000000100100010100100101101111100011010100111101110010000001011111111"
+"1101010000011001010101111001111110001111100010100010100001011001110001010010100001011111110110111"
+"1100100100001111000111110111000100010101010110100111100001011001101001111101001110010110110011010"
+"1000010011000110000000110110110000111010010000111001100010100101010101111100010111000000011101110"
+"1100011010110001101100110000001010001100111101101011100111110111000110010011011011001101001111100"
+"1011111001100011010110101111100110111101011100000011000010001010001101001011000001111000101000100"
+"0110001011001010110000001101100000011000011110010000101000011010011110001101111111010010101100100"
+"1111010100000011011001111111011011111001101110101010110111110110101000100001011110111010100111100"
+"0000001001111100111111111000100000100100010001011001100001111100100000001111011101100010011000111"
+"0011110110100011011001110011100011011000010000000101101101001010111000010000010101111110000000100"
+"1011010100001001000011001100011000000111100111100101010100000111000000110111011101011111100010101"
+"0011001100110000010101111001000111001001010100011000110010011011101001001100101100000000111000111"
+"0111111000010010010100000101010010000100101011111111111001100101101010011010100010111001011100011"
+"1001001011010000110000111100010110110100000100110010000010010000001000110010101000110101101100100"
+"0001100001100011110110010000100000100010011001010010110111100011011000101011001100001111110110110"
+"0001100110010100011001101000100001110011011111101001101011110011011011111110111110101110010011001"
+"1000000101100000101100100000100000001011000100100001100100101101010111101010111101010001001010110"
+"0011111011001101001110110010100100000011001001111010001001100101110000000010111101000111111101010"
+"0110101110101110001001110000111110100000101101100110010001111101111011001000101110111010110111110"
+"0011001101011010001011000010000111111111101001011100110101011000000001111000101100011101011011100"
+"1111101110000000000110001110011001101100111111010001110000111110100011000100001100110010000110111"
+"1001011011001111011100000000011011000100000011000010010111000111101000011001001100011010001111000"
+"0011110010100010001101011101010011001100000010101001001101111101000111001110110000000010111101001"
+"1110110011101110111010011100101001010101100100011111100110001111011111110010100000011100110110001"
+"1011100000101000010100011101000010111100101111101100110001010001010000101110000000110100010110011"
+"1111110100101010011010100001100110110110011111110010000100001010011110010110001000000100000111000"
+"0111001010011001000010111001100110100110110101111011110111001001000101010010010011000111110010101"
+"1100110001100101001000010001101010011001110011001110001110010100010000000000000110111001010101000"
+"0111111011011101000111011001011011000101110100010001111100101110000100001011111101111101010011001"
+"0010001100011011101100010010101011001000001001010101100110001111001110011100110111111010110010001"
+"1111111101111001001101101001001010011001110000101000110010111110010110111111000100101000101011010"
+"0000101101101100000110101000101000010001111000100000111110011111111110010010001010001111011001100"
+"0011110111000000111111000100001111101110100010101011001010110110011001010010001011100001010110101"
+"0100000010101101000011001101110010000010110011000101100100000111111100011001110011010011001110000"
+"1110011110000000001001001010100000111001010110001110011100011010010010001110010011001010111100000"
+"1110000101101001011010001001010000111000010011010100001010110000101101110110011000011100111100001"
+"1001000011010001110110111001100100001111110010110010011111000010100000001101110100000000101101000"
+"0011000000100011000111110001000011100111110110000110101111101100011110100111111000000011011110110"
+"1101011010111010010001001101000110110010000010101000000001100100100000001111011001001010110100011"
+"1011000010101111010111000001001100111110000010110010011011110011111001000101111011010011010100001"
+"0110011111100001011111101010010100110001001001001000100010101011011000011100111000110101110000001"
+"1100001111100011110010000101011000010101111010001101010101100001100101100000100100000101011001100"
+"0011001000101010101010100111000100100010101000111111101010000000101010101001000101010100100111001"
+"1001100001010001100110111101010001111010011100000001001110100010010011110100001000011111100010001"
+"0010001000100110101011001110100110101110110110100101111000110101101101001000001110011010110011001"
+"0111111101011011101001111001011100001010110111000001100010110110100011010111011000111010100011000"
+"1111010110001001010000110001000101101100010100000000100001111100000010111001000011000101010100001"
+"0001101100011100010100101110010100000010011011010100000111110110000110101011011010010001110000111"
+"0110101000110101110010011100010010100111001101110110010001101001101101010100001010001110111011011"
+"1010011001010111101001011000100111001110011000000001101000001111001100001100000011001110100110011"
+"0011000110001001010111111111110110111111000111100010010101110000101100101000001010001011010100010"
+"1010010100010011101111100111010010010001110101011110110100001000001001000111001110010001001100100"
+"1100100010001010011011110100000101101011101010110110100100010001110000111010111001111011111001011"
+"0000000000011000100100100111001000101111000000110001011110101111110111100000000100101011000111011"
+"1011010011101000001011001001110001111010000100101101010111001010001000100001000111011010000110111"
+"1010110001001110001100001110011000101100000101100000000110101000000110101100100101110001100100100"
+"0110000110101011100001010001010000011101111011111011011000100100101011110101111000001011110010110"
+"0111011011100111101010110001111011010011111000010111110100001001010001011001000110111100000101011"
+"0010111111010100000110111101001100000100001011101010100011010010000001101100100101001000100011000"
+"0101010111111100100000111011101111100000011011111111010001100011001100101101011110101011101100001"
+"0100010011101111111011000111111101001000101101111001111000101110010111001010101011010111000000101"
+"0110010000010010101111100010111110000000011101001000011111001011111100111100100101100101111010110"
+"1010101001110011111100111110100000111100100000111111000010100001111011111110110010001001000000000"
+"1110100110010111100101111111001010001111001101100001011000111011100010100001000010100000011001000"
+"0000111000110111001001100010111010100111111001111101100101000011001001110011100110101110001101110"
+"1110000010110110010110000111001110110000011011100111000101100101000000001110011011001001111001111"
+"0000101100001000000111100110110000110111111001101001111111010000001011110011011011100100110000110"
+"1001011111101100100111111000000010001110111011010011011101001100000011001010000010101111111010110"
+"0001000100101110101101100001001010100110010000110110100110011001000111011110110011001110111110101"
+"0000011111011011001111010010101011000010011101001011100001010001111001000110000010000101010011111"
+"0110011000001111101001110001101011111111001010010110100001101000000011101000101011101000110101111"
+"0000101110011010010000110100000101100011000100101111100011001111011101001010100111001110100001101"
+"0000110111011000000110011001101011110000101100110110000101100000110110100001001001110001110001001"
+"1100110111111100101001100010010110011011110001000111111111001101111110010000011001011010111101001"
+"1101111110101110110100101100110001101101001010111101101000000011111111100101000101110001000011001"
+"1000111110111011010010101011110110110001010001001001100111111010011101111000000111011000011010011"
+"0111010101001110010100101101000110000110001100010101001110101011010100000110110111111111110011110"
+"0100011110100011001000110101111010000001011011110101001100111100010100101100010000010110011001111"
+"0011011110001110010010100100011111110000110011011100010110110101001110011010101111011001010101011"
+"1001001111001000001100100111000001000110110101100111000101011000000100001000100010011000001110011"
+"0000111100000111001101011111010000010001100000010101101000111100001000010011110000001011001001100"
+"0011011011111011100000111101001011101000010010001001111110010101111010110101101110110111010000101"
+"1100011000000000110110100011010100100010001101010101101110110111111011010110011101011010110101011"
+"1101000000010010011111000000101000110001000011100001101111010101100000100000100111111111100000000"
+"0011100011100101110010111100010111110010101110101000011000111111001110111111000001101101011011111"
+"1100110101001000011111001111000000001010001001010101101000001100111010101100010111001001111100000"
+"1110101101110001011100011101101100001001001011100111100110011101111000100010010001111100001010010"
+"1011001001010100101100010010000110010000101010111111001000011100000000101101110010001101110101001"
+"1110000011100101010000011110000010001000001010110001010000100111001100110001111000100100011100110"
+"1100010011110111001001100000100111001010000000000011100011111111101110010101111010100010000100001"
+"0101101001010111111110000110110010100000001011110100010111110111010000001011110110111000000110010"
+"0001100100111110001100010101000010011111100000100010000101110000111001101100100000011111111100010"
+"1001101101001000001111000100100001010110111011110110001001010001110001001100011001001100000000101"
+"1100011110101101011001100001010110001010000111100000011011011001000010101100010101110011001101110"
+"0000101011010001010011111001011000010101010100110110111110101000111110001000010100000000100010100"
+"1000111111000110110010001111000010101011101101111101011110101111100111111100111101000101000010011"
+"0010111010100010011001000000010111100010000101001011001101100011100001001111010100100110101111111"
+"1000010011110101001010011111111011101001110100001001100010000100001001100101101111011100100011001"
+"1111010001011001111101011110101101000111110101001010011101010010010101001000000000011001100110001"
+"0001000010101010101000010100111000001110000111001110001101111111000010101010111001011101001001011"
+"0011001111011010101110101111110001001100100111010001011000010100000100000001001100000011000011101"
+"1100000110000001011001110000101001010111101000110101000011000000111011100101010000111000010010101"
+"1010100101100001011011011110110011000100100101010011111101000000100001001101000011000101010111101"
+"1110111111100010111000111000010110111010010110000000000100101001000111101101100000000110111011001"
+"0100000000100100011110111011101101101101010110001110100001100001001011000000111111110100011110011"
+"0010000010000000010100110011110000000010000011111000111101011110000000000010101101001100000010010"
+"1011001001101110110011100001100011101001101011110011010001011101000100011111001010100000011111111"
+"1010101100000010001000110000110000101000110100110011100000110010110100011111010001000011100001001"
+"1000101000010111111011100010111000111001010100110000000010011011101010101111000110001000110111011"
+"1011100001100011010001101011010100110110011100000010111001011111110010100110100010001100000011100"
+"0001011001011000101011010000001010011010001011000111000011000011110011111001111010001101011010010"
+"0010010001001001101000101001011011101110001100010001010100010111111001100100000010001111100010111"
+"0100001111001100101001011101010010110010100010001100011010100110000100011010111110001011011001000"
+"1001001111011010010011101110100001111100000110101001010111110001101100110010111010111001011111010"
+"1110111011111110000001110010000010011111000111011011000011000010011110011111111101100101111011100"
+"0101101100000110101110000111111111111010110101010100111000011111011001100000100000101011000101110"
+"1011010010100000000100100000010111101110111001000011111011111110100011010010000110001101111101100"
+"1100010111001011011001011001010100100110100101001000111011011001100011001010010101111001100100110"
+"1000110000111011100101110101101000011001010010100011000001111001110110101101010010110110001100100"
+"0100001011101100111001010001111011010110010010110010110111110001001001111001111010010001010001101"
+"1110100110101100011110100100110111000111010110011000100100110110001101111100111110100001000110000"
+"1110011011001101100101100000001010100011101000010100111011111100011010000110000001011100010000101"
+"0100101000010001110010001100010110011111111101111000011001110111011100110010010100100010001000010"
+"0100001110010000011000110001101011101001110100100011011001000111010101110100110011010111001100001"
+"0100001001101010010111110101110111000000010100111101011010101001000001001000001000101101111000000"
+"0110000101110100001111001101110111011110010111101000100101110111010101001101100001110001101101101"
+"0010101100100101000100100100110111000111000111100111000001100001000111101011000110111110001010000"
+"0100110010001101100011010111000111010111000111110000110000101111101110010110111001011000111010001"
+"1011000010010101010010011001000011010110111011010001001010100111001000010110110110101110000110000"
+"1110110010011001011011000100011101001001000111011100100000000000100001101101000101000100000111001"
+"0011100001100110101011011101110111101111000100100011100001010001011001110010101010001110101101110"
+"1011001110111111111010101101000010111111011011011100011100101010001011011100011111011100101011000"
+"1000110100101000011111010011110000000101101110010000101100001000100000000010010110000000000110011"
+"1000000000001111001001000100000111001110111111001111101100001100111000101100011000100111111110011"
+"1110010101011010111100110010110001010000101111111101001010100010001001111010111000010000010010001"
+"1111111101100100001101011011100001010101000111110111111101011010011111111101000111011001011011000"
+"0000101011100011101110110011101111011110011110010000011001111001110111011011111010011011001110111"
+"0101100111110100000100010110010010101001010100010111000101111001011011001001110010100011101111110"
+"1101011110010101101011010010011111110000011010011101000000010000111010100100111110111000001101010"
+"0101100001111001111010101011110001001010000011010110010100011100100100111110100110000010011111001"
+"0100010011001001010101110111111010011101101100000101011110111010011110001111110100111011110011010"
+"0111001010110101010110000011001010000000101101010101001101011000011011010110101010101111101101100"
+"1100100000111101010111011011011110011001100010010000010100101000111111101011100111010101011000111"
+"1100110010101100010011111100000110011111101011100100001110001100001010101001001100010011001000100"
+"1101101000101101110010000001101001001110101111000110111000011101111110100100110111000000101011110"
+"0001100100001010101001101111001000001100000011010000100101100000001110100010010000110110101010111"
+"1100010100000110011100101010111110010110111100000010110011011001011110111001010011011110010001110"
+"1101110000001011101101011111101011111110110110000111110011101100110100010000100000110100010010110"
+"0011000011000110101001110100111010110000100010110101110111100010110001000111100111001011011110010"
+"0001001110101001101101011010111001001101100011101001011011001110011010001010110100111001111100101"
+"1000111001010010000010111010101110001100110111111000011101001000001010010011101000111001100111110"
+"1110100100100110010111111101010011101111011011111011011010011110100101100001011000001001001010010"
+"1100001000000110110011011101010001011110010001001110110100100001101101001011101010001110111111010"
+"1100011100101000011110111110110011111111100010110010110111010010001111101110011011010110000001000"
+"0010110100010101110100001000010011100110001110001110010100010010010110011100100110010100001110011"
+"1100001011010000001101011011011110100000001110100111001000101000001000001001000010000111010000100"
+"0111100000101010110010111010010101100000001100110101001001000110001110111011110001010010010011000"
+"1100001111101101100001111000101100110010001000111001101101011110100110100011101000011111011010101"
+"0101000011111010010110001001100110110111000100100011011101000010001010110001111001111101110001111"
+"0100100000010111010011111110000101001001011110100100010011101110011010100101100001010000001110100"
+"0011111101111000100110011000011001100100001010110011111100111010100011110100010101011110011001000"
+"0000110000100100001011101110111010001001011110010101111100001111101101111011011110001010000100010"
+"1001100100100100110010010101100110000000100000000111110011100111101001010000010000000000101011100"
+"0011101011100110000001100101010101011111111011010011110010011011001010011101010010100010001011010"
+"1100010011101011010111110100001010100011000011001001011011101111110011001110010001100101011001101"
+"0100010001111111100000101000001011010100011100111011010111001100110110001100110101000011010001010"
+"1011100001001010011110001010100100001101110011101011100100101010001100110011110010001100100001000"
+"0110001001110110010111101011101101010111001010011010101110000010100010000111011000010110011000001"
+"1000110010100001110001100010010000001101111110000010010110100000000000001111110010001110111100001"
+"0100111101000011101110010101011011000101011010111100111111001011110001110011110011011010010111101"
+"1010111011101101000001110111001010011001110010100100100100001010001100101010111001110100000110111"
+"1010000111000011101101100101101001100000011100100111100110010110011100101000111110111000110111110"
+"1101100101011101100111011111111001111000011110111110101100000111000101100100110111000010100101000"
+"0110000011011101111101111000110101011000010111010000111011000000100011101010100111001111101010111"
+"0001110100001000100001011101001010001110100000101100001011101111100111101011111001111100101101111"
+"0101100001110011111110110100110010000011011111101101110110000110110011100110111000111101000010111"
+"0111101011100100000000011101111011000100001000111000000111011010101010110000111111101010110001111"
+"0000110100111101111011001010101110000011001101001101000010011001101011111110111101010111010011100"
+"0101010011001111101111001100101000101000111110111001011111100000001101111011000001001100111111111"
+"1010111101000001111011110010001001001110100111110010000011110000011000000101001100011110110011001"
+"1010101001000010001010110000010011110101011110010111010001010111101100001001100011101001111101001"
+"0110110100111001110011100011111010010010100010111000001100001011010010000100100110101010111001001"
+"0110000101011011011100110111111001010000001001011010101010010001011010111100111010101101000101101"
+"0100100001011101110111111001111111110110111011000101010000010000011111001000100101100100100110110"
+"1100000111110010110011010100000100011111110001110010110001000001001111001101110110110101101010111"
+"0000100111101100010001110010110111100011100101100011";
diff --git a/numpy/random/src/mt19937/mt19937-test-data-gen.c b/numpy/random/src/mt19937/mt19937-test-data-gen.c
new file mode 100644
index 000000000..4f4ec1d64
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937-test-data-gen.c
@@ -0,0 +1,59 @@
+/*
+ * Generate testing csv files
+ *
+ * cl mt19937-test-data-gen.c randomkit.c
+ *   -IC:\Anaconda\Lib\site-packages\numpy\core\include -IC:\Anaconda\include
+ *   Advapi32.lib Kernel32.lib C:\Anaconda\libs\python36.lib  -DRK_NO_WINCRYPT=1
+ *
+ */
+#include "randomkit.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  uint64_t sum = 0;
+  uint32_t seed = 0xDEADBEAF;
+  int i;
+  rk_state state;
+  rk_seed(seed, &state);
+  uint64_t store[N];
+  for (i = 0; i < N; i++) {
+    store[i] = (uint64_t)rk_random(&state);
+  }
+
+  FILE *fp;
+  fp = fopen("mt19937-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx32 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  seed = 0;
+  rk_seed(seed, &state);
+  for (i = 0; i < N; i++) {
+    store[i] = (uint64_t)rk_random(&state);
+  }
+  fp = fopen("mt19937-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx32 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/mt19937/mt19937.c b/numpy/random/src/mt19937/mt19937.c
new file mode 100644
index 000000000..e5ca9e0cf
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937.c
@@ -0,0 +1,107 @@
+#include "mt19937.h"
+#include "mt19937-jump.h"
+#include "mt19937-poly.h"
+
+void mt19937_seed(mt19937_state *state, uint32_t seed) {
+  int pos;
+  seed &= 0xffffffffUL;
+
+  /* Knuth's PRNG as used in the Mersenne Twister reference implementation */
+  for (pos = 0; pos < RK_STATE_LEN; pos++) {
+    state->key[pos] = seed;
+    seed = (1812433253UL * (seed ^ (seed >> 30)) + pos + 1) & 0xffffffffUL;
+  }
+  state->pos = RK_STATE_LEN;
+}
+
+/* initializes mt[RK_STATE_LEN] with a seed */
+static void init_genrand(mt19937_state *state, uint32_t s) {
+  int mti;
+  uint32_t *mt = state->key;
+
+  mt[0] = s & 0xffffffffUL;
+  for (mti = 1; mti < RK_STATE_LEN; mti++) {
+    /*
+     * See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
+     * In the previous versions, MSBs of the seed affect
+     * only MSBs of the array mt[].
+     * 2002/01/09 modified by Makoto Matsumoto
+     */
+    mt[mti] = (1812433253UL * (mt[mti - 1] ^ (mt[mti - 1] >> 30)) + mti);
+    /* for > 32 bit machines */
+    mt[mti] &= 0xffffffffUL;
+  }
+  state->pos = mti;
+  return;
+}
+
+/*
+ * initialize by an array with array-length
+ * init_key is the array for initializing keys
+ * key_length is its length
+ */
+void mt19937_init_by_array(mt19937_state *state, uint32_t *init_key,
+                           int key_length) {
+  /* was signed in the original code. RDH 12/16/2002 */
+  int i = 1;
+  int j = 0;
+  uint32_t *mt = state->key;
+  int k;
+
+  init_genrand(state, 19650218UL);
+  k = (RK_STATE_LEN > key_length ? RK_STATE_LEN : key_length);
+  for (; k; k--) {
+    /* non linear */
+    mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >> 30)) * 1664525UL)) +
+            init_key[j] + j;
+    /* for > 32 bit machines */
+    mt[i] &= 0xffffffffUL;
+    i++;
+    j++;
+    if (i >= RK_STATE_LEN) {
+      mt[0] = mt[RK_STATE_LEN - 1];
+      i = 1;
+    }
+    if (j >= key_length) {
+      j = 0;
+    }
+  }
+  for (k = RK_STATE_LEN - 1; k; k--) {
+    mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >> 30)) * 1566083941UL)) -
+            i;             /* non linear */
+    mt[i] &= 0xffffffffUL; /* for WORDSIZE > 32 machines */
+    i++;
+    if (i >= RK_STATE_LEN) {
+      mt[0] = mt[RK_STATE_LEN - 1];
+      i = 1;
+    }
+  }
+
+  mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
+}
+
+void mt19937_gen(mt19937_state *state) {
+  uint32_t y;
+  int i;
+
+  for (i = 0; i < N - M; i++) {
+    y = (state->key[i] & UPPER_MASK) | (state->key[i + 1] & LOWER_MASK);
+    state->key[i] = state->key[i + M] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
+  }
+  for (; i < N - 1; i++) {
+    y = (state->key[i] & UPPER_MASK) | (state->key[i + 1] & LOWER_MASK);
+    state->key[i] = state->key[i + (M - N)] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
+  }
+  y = (state->key[N - 1] & UPPER_MASK) | (state->key[0] & LOWER_MASK);
+  state->key[N - 1] = state->key[M - 1] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
+
+  state->pos = 0;
+}
+
+extern inline uint64_t mt19937_next64(mt19937_state *state);
+
+extern inline uint32_t mt19937_next32(mt19937_state *state);
+
+extern inline double mt19937_next_double(mt19937_state *state);
+
+void mt19937_jump(mt19937_state *state) { mt19937_jump_state(state, poly); }
diff --git a/numpy/random/src/mt19937/mt19937.h b/numpy/random/src/mt19937/mt19937.h
new file mode 100644
index 000000000..8105329ec
--- /dev/null
+++ b/numpy/random/src/mt19937/mt19937.h
@@ -0,0 +1,69 @@
+#pragma once
+#include <math.h>
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/stdint.h"
+#else
+#include <stdint.h>
+#endif
+#else
+#include <stdint.h>
+#endif
+
+#ifdef _WIN32
+#define inline __forceinline
+#endif
+
+#define RK_STATE_LEN 624
+
+#define N 624
+#define M 397
+#define MATRIX_A 0x9908b0dfUL
+#define UPPER_MASK 0x80000000UL
+#define LOWER_MASK 0x7fffffffUL
+
+typedef struct s_mt19937_state {
+  uint32_t key[RK_STATE_LEN];
+  int pos;
+} mt19937_state;
+
+extern void mt19937_seed(mt19937_state *state, uint32_t seed);
+
+extern void mt19937_gen(mt19937_state *state);
+
+/* Slightly optimized reference implementation of the Mersenne Twister */
+static inline uint32_t mt19937_next(mt19937_state *state) {
+  uint32_t y;
+
+  if (state->pos == RK_STATE_LEN) {
+    // Move to function to help inlining
+    mt19937_gen(state);
+  }
+  y = state->key[state->pos++];
+
+  /* Tempering */
+  y ^= (y >> 11);
+  y ^= (y << 7) & 0x9d2c5680UL;
+  y ^= (y << 15) & 0xefc60000UL;
+  y ^= (y >> 18);
+
+  return y;
+}
+
+extern void mt19937_init_by_array(mt19937_state *state, uint32_t *init_key,
+                                  int key_length);
+
+static inline uint64_t mt19937_next64(mt19937_state *state) {
+  return (uint64_t)mt19937_next(state) << 32 | mt19937_next(state);
+}
+
+static inline uint32_t mt19937_next32(mt19937_state *state) {
+  return mt19937_next(state);
+}
+
+static inline double mt19937_next_double(mt19937_state *state) {
+  int32_t a = mt19937_next(state) >> 5, b = mt19937_next(state) >> 6;
+  return (a * 67108864.0 + b) / 9007199254740992.0;
+}
+
+void mt19937_jump(mt19937_state *state);
diff --git a/numpy/random/src/mt19937/randomkit.c b/numpy/random/src/mt19937/randomkit.c
new file mode 100644
index 000000000..f8ed4b49e
--- /dev/null
+++ b/numpy/random/src/mt19937/randomkit.c
@@ -0,0 +1,578 @@
+/* Random kit 1.3 */
+
+/*
+ * Copyright (c) 2003-2005, Jean-Sebastien Roy (js@jeannot.org)
+ *
+ * The rk_random and rk_seed functions algorithms and the original design of
+ * the Mersenne Twister RNG:
+ *
+ *   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ *   3. The names of its contributors may not be used to endorse or promote
+ *   products derived from this software without specific prior written
+ *   permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ *   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ *   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ *   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Original algorithm for the implementation of rk_interval function from
+ * Richard J. Wagner's implementation of the Mersenne Twister RNG, optimised by
+ * Magnus Jonsson.
+ *
+ * Constants used in the rk_double implementation by Isaku Wada.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* static char const rcsid[] =
+  "@(#) $Jeannot: randomkit.c,v 1.28 2005/07/21 22:14:09 js Exp $"; */
+
+#ifdef _WIN32
+/*
+ * Windows
+ * XXX: we have to use this ugly defined(__GNUC__) because it is not easy to
+ * detect the compiler used in distutils itself
+ */
+#if (defined(__GNUC__) && defined(NPY_NEEDS_MINGW_TIME_WORKAROUND))
+
+/*
+ * FIXME: ideally, we should set this to the real version of MSVCRT. We need
+ * something higher than 0x601 to enable _ftime64 and co
+ */
+#define __MSVCRT_VERSION__ 0x0700
+#include <sys/timeb.h>
+#include <time.h>
+
+/*
+ * mingw msvcr lib import wrongly export _ftime, which does not exist in the
+ * actual msvc runtime for version >= 8; we make it an alias to _ftime64, which
+ * is available in those versions of the runtime
+ */
+#define _FTIME(x) _ftime64((x))
+#else
+#include <sys/timeb.h>
+#include <time.h>
+
+#define _FTIME(x) _ftime((x))
+#endif
+
+#ifndef RK_NO_WINCRYPT
+/* Windows crypto */
+#ifndef _WIN32_WINNT
+#define _WIN32_WINNT 0x0400
+#endif
+#include <wincrypt.h>
+#include <windows.h>
+
+#endif
+
+/*
+ * Do not move this include. randomkit.h must be included
+ * after windows timeb.h is included.
+ */
+#include "randomkit.h"
+
+#else
+/* Unix */
+#include "randomkit.h"
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <math.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef RK_DEV_URANDOM
+#define RK_DEV_URANDOM "/dev/urandom"
+#endif
+
+#ifndef RK_DEV_RANDOM
+#define RK_DEV_RANDOM "/dev/random"
+#endif
+
+char *rk_strerror[RK_ERR_MAX] = {"no error", "random device unvavailable"};
+
+/* static functions */
+static unsigned long rk_hash(unsigned long key);
+
+void rk_seed(unsigned long seed, rk_state *state) {
+  int pos;
+  seed &= 0xffffffffUL;
+
+  /* Knuth's PRNG as used in the Mersenne Twister reference implementation */
+  for (pos = 0; pos < RK_STATE_LEN; pos++) {
+    state->key[pos] = seed;
+    seed = (1812433253UL * (seed ^ (seed >> 30)) + pos + 1) & 0xffffffffUL;
+  }
+  state->pos = RK_STATE_LEN;
+  state->gauss = 0;
+  state->has_gauss = 0;
+  state->has_binomial = 0;
+}
+
+/* Thomas Wang 32 bits integer hash function */
+unsigned long rk_hash(unsigned long key) {
+  key += ~(key << 15);
+  key ^= (key >> 10);
+  key += (key << 3);
+  key ^= (key >> 6);
+  key += ~(key << 11);
+  key ^= (key >> 16);
+  return key;
+}
+
+rk_error rk_randomseed(rk_state *state) {
+#ifndef _WIN32
+  struct timeval tv;
+#else
+  struct _timeb tv;
+#endif
+  int i;
+
+  if (rk_devfill(state->key, sizeof(state->key), 0) == RK_NOERR) {
+    /* ensures non-zero key */
+    state->key[0] |= 0x80000000UL;
+    state->pos = RK_STATE_LEN;
+    state->gauss = 0;
+    state->has_gauss = 0;
+    state->has_binomial = 0;
+
+    for (i = 0; i < 624; i++) {
+      state->key[i] &= 0xffffffffUL;
+    }
+    return RK_NOERR;
+  }
+
+#ifndef _WIN32
+  gettimeofday(&tv, NULL);
+  rk_seed(rk_hash(getpid()) ^ rk_hash(tv.tv_sec) ^ rk_hash(tv.tv_usec) ^
+              rk_hash(clock()),
+          state);
+#else
+  _FTIME(&tv);
+  rk_seed(rk_hash(tv.time) ^ rk_hash(tv.millitm) ^ rk_hash(clock()), state);
+#endif
+
+  return RK_ENODEV;
+}
+
+/* Magic Mersenne Twister constants */
+#define N 624
+#define M 397
+#define MATRIX_A 0x9908b0dfUL
+#define UPPER_MASK 0x80000000UL
+#define LOWER_MASK 0x7fffffffUL
+
+/*
+ * Slightly optimised reference implementation of the Mersenne Twister
+ * Note that regardless of the precision of long, only 32 bit random
+ * integers are produced
+ */
+unsigned long rk_random(rk_state *state) {
+  unsigned long y;
+
+  if (state->pos == RK_STATE_LEN) {
+    int i;
+
+    for (i = 0; i < N - M; i++) {
+      y = (state->key[i] & UPPER_MASK) | (state->key[i + 1] & LOWER_MASK);
+      state->key[i] = state->key[i + M] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
+    }
+    for (; i < N - 1; i++) {
+      y = (state->key[i] & UPPER_MASK) | (state->key[i + 1] & LOWER_MASK);
+      state->key[i] =
+          state->key[i + (M - N)] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
+    }
+    y = (state->key[N - 1] & UPPER_MASK) | (state->key[0] & LOWER_MASK);
+    state->key[N - 1] = state->key[M - 1] ^ (y >> 1) ^ (-(y & 1) & MATRIX_A);
+
+    state->pos = 0;
+  }
+  y = state->key[state->pos++];
+
+  /* Tempering */
+  y ^= (y >> 11);
+  y ^= (y << 7) & 0x9d2c5680UL;
+  y ^= (y << 15) & 0xefc60000UL;
+  y ^= (y >> 18);
+
+  return y;
+}
+
+/*
+ * Returns an unsigned 64 bit random integer.
+ */
+NPY_INLINE static npy_uint64 rk_uint64(rk_state *state) {
+  npy_uint64 upper = (npy_uint64)rk_random(state) << 32;
+  npy_uint64 lower = (npy_uint64)rk_random(state);
+  return upper | lower;
+}
+
+/*
+ * Returns an unsigned 32 bit random integer.
+ */
+NPY_INLINE static npy_uint32 rk_uint32(rk_state *state) {
+  return (npy_uint32)rk_random(state);
+}
+
+/*
+ * Fills an array with cnt random npy_uint64 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void rk_random_uint64(npy_uint64 off, npy_uint64 rng, npy_intp cnt,
+                      npy_uint64 *out, rk_state *state) {
+  npy_uint64 val, mask = rng;
+  npy_intp i;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+    return;
+  }
+
+  /* Smallest bit mask >= max */
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+  mask |= mask >> 8;
+  mask |= mask >> 16;
+  mask |= mask >> 32;
+
+  for (i = 0; i < cnt; i++) {
+    if (rng <= 0xffffffffUL) {
+      while ((val = (rk_uint32(state) & mask)) > rng)
+        ;
+    } else {
+      while ((val = (rk_uint64(state) & mask)) > rng)
+        ;
+    }
+    out[i] = off + val;
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_uint32 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void rk_random_uint32(npy_uint32 off, npy_uint32 rng, npy_intp cnt,
+                      npy_uint32 *out, rk_state *state) {
+  npy_uint32 val, mask = rng;
+  npy_intp i;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+    return;
+  }
+
+  /* Smallest bit mask >= max */
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+  mask |= mask >> 8;
+  mask |= mask >> 16;
+
+  for (i = 0; i < cnt; i++) {
+    while ((val = (rk_uint32(state) & mask)) > rng)
+      ;
+    out[i] = off + val;
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_uint16 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void rk_random_uint16(npy_uint16 off, npy_uint16 rng, npy_intp cnt,
+                      npy_uint16 *out, rk_state *state) {
+  npy_uint16 val, mask = rng;
+  npy_intp i;
+  npy_uint32 buf;
+  int bcnt = 0;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+    return;
+  }
+
+  /* Smallest bit mask >= max */
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+  mask |= mask >> 8;
+
+  for (i = 0; i < cnt; i++) {
+    do {
+      if (!bcnt) {
+        buf = rk_uint32(state);
+        bcnt = 1;
+      } else {
+        buf >>= 16;
+        bcnt--;
+      }
+      val = (npy_uint16)buf & mask;
+    } while (val > rng);
+    out[i] = off + val;
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_uint8 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+void rk_random_uint8(npy_uint8 off, npy_uint8 rng, npy_intp cnt, npy_uint8 *out,
+                     rk_state *state) {
+  npy_uint8 val, mask = rng;
+  npy_intp i;
+  npy_uint32 buf;
+  int bcnt = 0;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+    return;
+  }
+
+  /* Smallest bit mask >= max */
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+
+  for (i = 0; i < cnt; i++) {
+    do {
+      if (!bcnt) {
+        buf = rk_uint32(state);
+        bcnt = 3;
+      } else {
+        buf >>= 8;
+        bcnt--;
+      }
+      val = (npy_uint8)buf & mask;
+    } while (val > rng);
+    out[i] = off + val;
+  }
+}
+
+/*
+ * Fills an array with cnt random npy_bool between off and off + rng
+ * inclusive.
+ */
+void rk_random_bool(npy_bool off, npy_bool rng, npy_intp cnt, npy_bool *out,
+                    rk_state *state) {
+  npy_intp i;
+  npy_uint32 buf;
+  int bcnt = 0;
+
+  if (rng == 0) {
+    for (i = 0; i < cnt; i++) {
+      out[i] = off;
+    }
+    return;
+  }
+
+  /* If we reach here rng and mask are one and off is zero */
+  assert(rng == 1 && off == 0);
+  for (i = 0; i < cnt; i++) {
+    if (!bcnt) {
+      buf = rk_uint32(state);
+      bcnt = 31;
+    } else {
+      buf >>= 1;
+      bcnt--;
+    }
+    out[i] = (buf & 0x00000001) != 0;
+  }
+}
+
+long rk_long(rk_state *state) { return rk_ulong(state) >> 1; }
+
+unsigned long rk_ulong(rk_state *state) {
+#if ULONG_MAX <= 0xffffffffUL
+  return rk_random(state);
+#else
+  return (rk_random(state) << 32) | (rk_random(state));
+#endif
+}
+
+unsigned long rk_interval(unsigned long max, rk_state *state) {
+  unsigned long mask = max, value;
+
+  if (max == 0) {
+    return 0;
+  }
+  /* Smallest bit mask >= max */
+  mask |= mask >> 1;
+  mask |= mask >> 2;
+  mask |= mask >> 4;
+  mask |= mask >> 8;
+  mask |= mask >> 16;
+#if ULONG_MAX > 0xffffffffUL
+  mask |= mask >> 32;
+#endif
+
+  /* Search a random value in [0..mask] <= max */
+#if ULONG_MAX > 0xffffffffUL
+  if (max <= 0xffffffffUL) {
+    while ((value = (rk_random(state) & mask)) > max)
+      ;
+  } else {
+    while ((value = (rk_ulong(state) & mask)) > max)
+      ;
+  }
+#else
+  while ((value = (rk_ulong(state) & mask)) > max)
+    ;
+#endif
+  return value;
+}
+
+double rk_double(rk_state *state) {
+  /* shifts : 67108864 = 0x4000000, 9007199254740992 = 0x20000000000000 */
+  long a = rk_random(state) >> 5, b = rk_random(state) >> 6;
+  return (a * 67108864.0 + b) / 9007199254740992.0;
+}
+
+void rk_fill(void *buffer, size_t size, rk_state *state) {
+  unsigned long r;
+  unsigned char *buf = buffer;
+
+  for (; size >= 4; size -= 4) {
+    r = rk_random(state);
+    *(buf++) = r & 0xFF;
+    *(buf++) = (r >> 8) & 0xFF;
+    *(buf++) = (r >> 16) & 0xFF;
+    *(buf++) = (r >> 24) & 0xFF;
+  }
+
+  if (!size) {
+    return;
+  }
+  r = rk_random(state);
+  for (; size; r >>= 8, size--) {
+    *(buf++) = (unsigned char)(r & 0xFF);
+  }
+}
+
+rk_error rk_devfill(void *buffer, size_t size, int strong) {
+#ifndef _WIN32
+  FILE *rfile;
+  int done;
+
+  if (strong) {
+    rfile = fopen(RK_DEV_RANDOM, "rb");
+  } else {
+    rfile = fopen(RK_DEV_URANDOM, "rb");
+  }
+  if (rfile == NULL) {
+    return RK_ENODEV;
+  }
+  done = fread(buffer, size, 1, rfile);
+  fclose(rfile);
+  if (done) {
+    return RK_NOERR;
+  }
+#else
+
+#ifndef RK_NO_WINCRYPT
+  HCRYPTPROV hCryptProv;
+  BOOL done;
+
+  if (!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
+                           CRYPT_VERIFYCONTEXT) ||
+      !hCryptProv) {
+    return RK_ENODEV;
+  }
+  done = CryptGenRandom(hCryptProv, size, (unsigned char *)buffer);
+  CryptReleaseContext(hCryptProv, 0);
+  if (done) {
+    return RK_NOERR;
+  }
+#endif
+
+#endif
+  return RK_ENODEV;
+}
+
+rk_error rk_altfill(void *buffer, size_t size, int strong, rk_state *state) {
+  rk_error err;
+
+  err = rk_devfill(buffer, size, strong);
+  if (err) {
+    rk_fill(buffer, size, state);
+  }
+  return err;
+}
+
+double rk_gauss(rk_state *state) {
+  if (state->has_gauss) {
+    const double tmp = state->gauss;
+    state->gauss = 0;
+    state->has_gauss = 0;
+    return tmp;
+  } else {
+    double f, x1, x2, r2;
+
+    do {
+      x1 = 2.0 * rk_double(state) - 1.0;
+      x2 = 2.0 * rk_double(state) - 1.0;
+      r2 = x1 * x1 + x2 * x2;
+    } while (r2 >= 1.0 || r2 == 0.0);
+
+    /* Polar method, a more efficient version of the Box-Muller approach. */
+    f = sqrt(-2.0 * log(r2) / r2);
+    /* Keep for next call */
+    state->gauss = f * x1;
+    state->has_gauss = 1;
+    return f * x2;
+  }
+}
diff --git a/numpy/random/src/mt19937/randomkit.h b/numpy/random/src/mt19937/randomkit.h
new file mode 100644
index 000000000..abb082cb2
--- /dev/null
+++ b/numpy/random/src/mt19937/randomkit.h
@@ -0,0 +1,223 @@
+/* Random kit 1.3 */
+
+/*
+ * Copyright (c) 2003-2005, Jean-Sebastien Roy (js@jeannot.org)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* @(#) $Jeannot: randomkit.h,v 1.24 2005/07/21 22:14:09 js Exp $ */
+
+/*
+ * Typical use:
+ *
+ * {
+ *  rk_state state;
+ *  unsigned long seed = 1, random_value;
+ *
+ *  rk_seed(seed, &state); // Initialize the RNG
+ *  ...
+ *  random_value = rk_random(&state); // Generate random values in [0..RK_MAX]
+ * }
+ *
+ * Instead of rk_seed, you can use rk_randomseed which will get a random seed
+ * from /dev/urandom (or the clock, if /dev/urandom is unavailable):
+ *
+ * {
+ *  rk_state state;
+ *  unsigned long random_value;
+ *
+ *  rk_randomseed(&state); // Initialize the RNG with a random seed
+ *  ...
+ *  random_value = rk_random(&state); // Generate random values in [0..RK_MAX]
+ * }
+ */
+
+/*
+ * Useful macro:
+ *  RK_DEV_RANDOM: the device used for random seeding.
+ *                 defaults to "/dev/urandom"
+ */
+
+#ifndef _RANDOMKIT_
+#define _RANDOMKIT_
+
+#include <numpy/npy_common.h>
+#include <stddef.h>
+
+#define RK_STATE_LEN 624
+
+typedef struct rk_state_ {
+  unsigned long key[RK_STATE_LEN];
+  int pos;
+  int has_gauss; /* !=0: gauss contains a gaussian deviate */
+  double gauss;
+
+  /* The rk_state structure has been extended to store the following
+   * information for the binomial generator. If the input values of n or p
+   * are different than nsave and psave, then the other parameters will be
+   * recomputed. RTK 2005-09-02 */
+
+  int has_binomial; /* !=0: following parameters initialized for
+                            binomial */
+  double psave;
+  long nsave;
+  double r;
+  double q;
+  double fm;
+  long m;
+  double p1;
+  double xm;
+  double xl;
+  double xr;
+  double c;
+  double laml;
+  double lamr;
+  double p2;
+  double p3;
+  double p4;
+
+} rk_state;
+
+typedef enum {
+  RK_NOERR = 0,  /* no error */
+  RK_ENODEV = 1, /* no RK_DEV_RANDOM device */
+  RK_ERR_MAX = 2
+} rk_error;
+
+/* error strings */
+extern char *rk_strerror[RK_ERR_MAX];
+
+/* Maximum generated random value */
+#define RK_MAX 0xFFFFFFFFUL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Initialize the RNG state using the given seed.
+ */
+extern void rk_seed(unsigned long seed, rk_state *state);
+
+/*
+ * Initialize the RNG state using a random seed.
+ * Uses /dev/random or, when unavailable, the clock (see randomkit.c).
+ * Returns RK_NOERR when no errors occurs.
+ * Returns RK_ENODEV when the use of RK_DEV_RANDOM failed (for example because
+ * there is no such device). In this case, the RNG was initialized using the
+ * clock.
+ */
+extern rk_error rk_randomseed(rk_state *state);
+
+/*
+ * Returns a random unsigned long between 0 and RK_MAX inclusive
+ */
+extern unsigned long rk_random(rk_state *state);
+
+/*
+ * Returns a random long between 0 and LONG_MAX inclusive
+ */
+extern long rk_long(rk_state *state);
+
+/*
+ * Returns a random unsigned long between 0 and ULONG_MAX inclusive
+ */
+extern unsigned long rk_ulong(rk_state *state);
+
+/*
+ * Returns a random unsigned long between 0 and max inclusive.
+ */
+extern unsigned long rk_interval(unsigned long max, rk_state *state);
+
+/*
+ * Fills an array with cnt random npy_uint64 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+extern void rk_random_uint64(npy_uint64 off, npy_uint64 rng, npy_intp cnt,
+                             npy_uint64 *out, rk_state *state);
+
+/*
+ * Fills an array with cnt random npy_uint32 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+extern void rk_random_uint32(npy_uint32 off, npy_uint32 rng, npy_intp cnt,
+                             npy_uint32 *out, rk_state *state);
+
+/*
+ * Fills an array with cnt random npy_uint16 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+extern void rk_random_uint16(npy_uint16 off, npy_uint16 rng, npy_intp cnt,
+                             npy_uint16 *out, rk_state *state);
+
+/*
+ * Fills an array with cnt random npy_uint8 between off and off + rng
+ * inclusive. The numbers wrap if rng is sufficiently large.
+ */
+extern void rk_random_uint8(npy_uint8 off, npy_uint8 rng, npy_intp cnt,
+                            npy_uint8 *out, rk_state *state);
+
+/*
+ * Fills an array with cnt random npy_bool between off and off + rng
+ * inclusive. It is assumed tha npy_bool as the same size as npy_uint8.
+ */
+extern void rk_random_bool(npy_bool off, npy_bool rng, npy_intp cnt,
+                           npy_bool *out, rk_state *state);
+
+/*
+ * Returns a random double between 0.0 and 1.0, 1.0 excluded.
+ */
+extern double rk_double(rk_state *state);
+
+/*
+ * fill the buffer with size random bytes
+ */
+extern void rk_fill(void *buffer, size_t size, rk_state *state);
+
+/*
+ * fill the buffer with randombytes from the random device
+ * Returns RK_ENODEV if the device is unavailable, or RK_NOERR if it is
+ * On Unix, if strong is defined, RK_DEV_RANDOM is used. If not, RK_DEV_URANDOM
+ * is used instead. This parameter has no effect on Windows.
+ * Warning: on most unixes RK_DEV_RANDOM will wait for enough entropy to answer
+ * which can take a very long time on quiet systems.
+ */
+extern rk_error rk_devfill(void *buffer, size_t size, int strong);
+
+/*
+ * fill the buffer using rk_devfill if the random device is available and using
+ * rk_fill if it is not
+ * parameters have the same meaning as rk_fill and rk_devfill
+ * Returns RK_ENODEV if the device is unavailable, or RK_NOERR if it is
+ */
+extern rk_error rk_altfill(void *buffer, size_t size, int strong,
+                           rk_state *state);
+
+/*
+ * return a random gaussian deviate with variance unity and zero mean.
+ */
+extern double rk_gauss(rk_state *state);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _RANDOMKIT_ */
diff --git a/numpy/random/src/pcg32/LICENSE.md b/numpy/random/src/pcg32/LICENSE.md
new file mode 100644
index 000000000..3db2ac2e8
--- /dev/null
+++ b/numpy/random/src/pcg32/LICENSE.md
@@ -0,0 +1,22 @@
+# PCG32
+
+PCG Random Number Generation for C.
+
+Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+For additional information about the PCG random number generation scheme,
+including its license and other licensing options, visit
+
+ http://www.pcg-random.org
diff --git a/numpy/random/src/pcg32/pcg-advance-64.c b/numpy/random/src/pcg32/pcg-advance-64.c
new file mode 100644
index 000000000..8210e7565
--- /dev/null
+++ b/numpy/random/src/pcg32/pcg-advance-64.c
@@ -0,0 +1,62 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *       http://www.pcg-random.org
+ */
+
+/*
+ * This code is derived from the canonical C++ PCG implementation, which
+ * has many additional features and is preferable if you can use C++ in
+ * your project.
+ *
+ * Repetative C code is derived using C preprocessor metaprogramming
+ * techniques.
+ */
+
+#include "pcg_variants.h"
+
+/* Multi-step advance functions (jump-ahead, jump-back)
+ *
+ * The method used here is based on Brown, "Random Number Generation
+ * with Arbitrary Stride,", Transactions of the American Nuclear
+ * Society (Nov. 1994).  The algorithm is very similar to fast
+ * exponentiation.
+ *
+ * Even though delta is an unsigned integer, we can pass a
+ * signed integer to go backwards, it just goes "the long way round".
+ */
+
+uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta, uint64_t cur_mult,
+                            uint64_t cur_plus)
+{
+    uint64_t acc_mult = 1u;
+    uint64_t acc_plus = 0u;
+    while (delta > 0) {
+        if (delta & 1) {
+            acc_mult *= cur_mult;
+            acc_plus = acc_plus * cur_mult + cur_plus;
+        }
+        cur_plus = (cur_mult + 1) * cur_plus;
+        cur_mult *= cur_mult;
+        delta /= 2;
+    }
+    return acc_mult * state + acc_plus;
+}
+
diff --git a/numpy/random/src/pcg32/pcg32-test-data-gen.c b/numpy/random/src/pcg32/pcg32-test-data-gen.c
new file mode 100644
index 000000000..cccaf84b9
--- /dev/null
+++ b/numpy/random/src/pcg32/pcg32-test-data-gen.c
@@ -0,0 +1,59 @@
+/*
+ * Generate testing csv files
+ *
+ *
+ * gcc  pcg32-test-data-gen.c pcg32.orig.c ../splitmix64/splitmix64.c -o
+ * pgc64-test-data-gen
+ */
+
+#include "pcg_variants.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  pcg32_random_t rng;
+  uint64_t inc, seed = 0xDEADBEAF;
+  inc = 0;
+  int i;
+  uint64_t store[N];
+  pcg32_srandom_r(&rng, seed, inc);
+  for (i = 0; i < N; i++) {
+    store[i] = pcg32_random_r(&rng);
+  }
+
+  FILE *fp;
+  fp = fopen("pcg32-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  seed = 0;
+  pcg32_srandom_r(&rng, seed, inc);
+  for (i = 0; i < N; i++) {
+    store[i] = pcg32_random_r(&rng);
+  }
+  fp = fopen("pcg32-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/pcg32/pcg32.c b/numpy/random/src/pcg32/pcg32.c
new file mode 100644
index 000000000..5fbf6759f
--- /dev/null
+++ b/numpy/random/src/pcg32/pcg32.c
@@ -0,0 +1,30 @@
+#include "pcg32.h"
+
+extern inline uint64_t pcg32_next64(pcg32_state *state);
+extern inline uint32_t pcg32_next32(pcg32_state *state);
+extern inline double pcg32_next_double(pcg32_state *state);
+
+uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta, uint64_t cur_mult,
+                            uint64_t cur_plus) {
+  uint64_t acc_mult, acc_plus;
+  acc_mult = 1u;
+  acc_plus = 0u;
+  while (delta > 0) {
+    if (delta & 1) {
+      acc_mult *= cur_mult;
+      acc_plus = acc_plus * cur_mult + cur_plus;
+    }
+    cur_plus = (cur_mult + 1) * cur_plus;
+    cur_mult *= cur_mult;
+    delta /= 2;
+  }
+  return acc_mult * state + acc_plus;
+}
+
+extern void pcg32_advance_state(pcg32_state *state, uint64_t step) {
+  pcg32_advance_r(state->pcg_state, step);
+}
+
+extern void pcg32_set_seed(pcg32_state *state, uint64_t seed, uint64_t inc) {
+  pcg32_srandom_r(state->pcg_state, seed, inc);
+}
diff --git a/numpy/random/src/pcg32/pcg32.h b/numpy/random/src/pcg32/pcg32.h
new file mode 100644
index 000000000..557113d8f
--- /dev/null
+++ b/numpy/random/src/pcg32/pcg32.h
@@ -0,0 +1,89 @@
+#ifndef _RANDOMDGEN__PCG32_H_
+#define _RANDOMDGEN__PCG32_H_
+
+#ifdef _WIN32
+#ifndef _INTTYPES
+#include "../common/stdint.h"
+#endif
+#define inline __inline __forceinline
+#else
+#include <inttypes.h>
+#endif
+
+#define PCG_DEFAULT_MULTIPLIER_64 6364136223846793005ULL
+
+struct pcg_state_setseq_64 {
+  uint64_t state;
+  uint64_t inc;
+};
+
+static inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot) {
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__)
+  asm("rorl   %%cl, %0" : "=r"(value) : "0"(value), "c"(rot));
+  return value;
+#else
+  return (value >> rot) | (value << ((-rot) & 31));
+#endif
+}
+
+static inline void pcg_setseq_64_step_r(struct pcg_state_setseq_64 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 + rng->inc;
+}
+
+static inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state) {
+  return pcg_rotr_32(((state >> 18u) ^ state) >> 27u, state >> 59u);
+}
+
+static inline uint32_t
+pcg_setseq_64_xsh_rr_32_random_r(struct pcg_state_setseq_64 *rng) {
+  uint64_t oldstate;
+  oldstate = rng->state;
+  pcg_setseq_64_step_r(rng);
+  return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+static inline void pcg_setseq_64_srandom_r(struct pcg_state_setseq_64 *rng,
+                                           uint64_t initstate,
+                                           uint64_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_64_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_64_step_r(rng);
+}
+
+extern uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta,
+                                   uint64_t cur_mult, uint64_t cur_plus);
+
+static inline void pcg_setseq_64_advance_r(struct pcg_state_setseq_64 *rng,
+                                           uint64_t delta) {
+  rng->state = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64,
+                                  rng->inc);
+}
+
+typedef struct pcg_state_setseq_64 pcg32_random_t;
+#define pcg32_random_r pcg_setseq_64_xsh_rr_32_random_r
+#define pcg32_srandom_r pcg_setseq_64_srandom_r
+#define pcg32_advance_r pcg_setseq_64_advance_r
+
+typedef struct s_pcg32_state { pcg32_random_t *pcg_state; } pcg32_state;
+
+static inline uint64_t pcg32_next64(pcg32_state *state) {
+  return (uint64_t)(pcg32_random_r(state->pcg_state)) << 32 |
+         pcg32_random_r(state->pcg_state);
+}
+
+static inline uint32_t pcg32_next32(pcg32_state *state) {
+  return pcg32_random_r(state->pcg_state);
+}
+
+static inline double pcg32_next_double(pcg32_state *state) {
+  int32_t a = pcg32_random_r(state->pcg_state) >> 5,
+          b = pcg32_random_r(state->pcg_state) >> 6;
+  return (a * 67108864.0 + b) / 9007199254740992.0;
+}
+
+void pcg32_advance_state(pcg32_state *state, uint64_t step);
+void pcg32_set_seed(pcg32_state *state, uint64_t seed, uint64_t inc);
+
+#endif
diff --git a/numpy/random/src/pcg32/pcg_variants.h b/numpy/random/src/pcg32/pcg_variants.h
new file mode 100644
index 000000000..32daac1ce
--- /dev/null
+++ b/numpy/random/src/pcg32/pcg_variants.h
@@ -0,0 +1,2210 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+/*
+ * This code is derived from the canonical C++ PCG implementation, which
+ * has many additional features and is preferable if you can use C++ in
+ * your project.
+ *
+ * Much of the derivation was performed mechanically.  In particular, the
+ * output functions were generated by compiling the C++ output functions
+ * into LLVM bitcode and then transforming that using the LLVM C backend
+ * (from https://github.com/draperlaboratory/llvm-cbe), and then
+ * postprocessing and hand editing the output.
+ *
+ * Much of the remaining code was generated by C-preprocessor metaprogramming.
+ */
+
+#ifndef PCG_VARIANTS_H_INCLUDED
+#define PCG_VARIANTS_H_INCLUDED 1
+
+#include <inttypes.h>
+
+#if __SIZEOF_INT128__
+    typedef __uint128_t pcg128_t;
+    #define PCG_128BIT_CONSTANT(high,low) \
+            ((((pcg128_t)high) << 64) + low)
+    #define PCG_HAS_128BIT_OPS 1
+#endif
+
+#if __GNUC_GNU_INLINE__  &&  !defined(__cplusplus)
+    #error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.
+    // We could instead use macros PCG_INLINE and PCG_EXTERN_INLINE
+    // but better to just reject ancient C code.
+#endif
+
+#if __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Rotate helper functions.
+ */
+
+inline uint8_t pcg_rotr_8(uint8_t value, unsigned int rot)
+{
+/* Unfortunately, clang is kinda pathetic when it comes to properly
+ * recognizing idiomatic rotate code, so for clang we actually provide
+ * assembler directives (enabled with PCG_USE_INLINE_ASM).  Boo, hiss.
+ */
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__  || __i386__)
+    asm ("rorb   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+#else
+    return (value >> rot) | (value << ((- rot) & 7));
+#endif
+}
+
+inline uint16_t pcg_rotr_16(uint16_t value, unsigned int rot)
+{
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__  || __i386__)
+    asm ("rorw   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+#else
+    return (value >> rot) | (value << ((- rot) & 15));
+#endif
+}
+
+inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot)
+{
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__  || __i386__)
+    asm ("rorl   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+#else
+    return (value >> rot) | (value << ((- rot) & 31));
+#endif
+}
+
+inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot)
+{
+#if 0 && PCG_USE_INLINE_ASM && __clang__ && __x86_64__
+    // For whatever reason, clang actually *does* generate rotq by
+    // itself, so we don't need this code.
+    asm ("rorq   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+#else
+    return (value >> rot) | (value << ((- rot) & 63));
+#endif
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_rotr_128(pcg128_t value, unsigned int rot)
+{
+    return (value >> rot) | (value << ((- rot) & 127));
+}
+#endif
+
+/*
+ * Output functions.  These are the core of the PCG generation scheme.
+ */
+
+// XSH RS
+
+inline uint8_t pcg_output_xsh_rs_16_8(uint16_t state)
+{
+    return (uint8_t)(((state >> 7u) ^ state) >> ((state >> 14u) + 3u));
+}
+
+inline uint16_t pcg_output_xsh_rs_32_16(uint32_t state)
+{
+    return (uint16_t)(((state >> 11u) ^ state) >> ((state >> 30u) + 11u));
+}
+
+inline uint32_t pcg_output_xsh_rs_64_32(uint64_t state)
+{
+
+    return (uint32_t)(((state >> 22u) ^ state) >> ((state >> 61u) + 22u));
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_output_xsh_rs_128_64(pcg128_t state)
+{
+    return (uint64_t)(((state >> 43u) ^ state) >> ((state >> 124u) + 45u));
+}
+#endif
+
+// XSH RR
+
+inline uint8_t pcg_output_xsh_rr_16_8(uint16_t state)
+{
+    return pcg_rotr_8(((state >> 5u) ^ state) >> 5u, state >> 13u);
+}
+
+inline uint16_t pcg_output_xsh_rr_32_16(uint32_t state)
+{
+    return pcg_rotr_16(((state >> 10u) ^ state) >> 12u, state >> 28u);
+}
+
+inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state)
+{
+    return pcg_rotr_32(((state >> 18u) ^ state) >> 27u, state >> 59u);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_output_xsh_rr_128_64(pcg128_t state)
+{
+    return pcg_rotr_64(((state >> 29u) ^ state) >> 58u, state >> 122u);
+}
+#endif
+
+// RXS M XS
+
+inline uint8_t pcg_output_rxs_m_xs_8_8(uint8_t state)
+{
+    uint8_t word = ((state >> ((state >> 6u) + 2u)) ^ state) * 217u;
+    return (word >> 6u) ^ word;
+}
+
+inline uint16_t pcg_output_rxs_m_xs_16_16(uint16_t state)
+{
+    uint16_t word = ((state >> ((state >> 13u) + 3u)) ^ state) * 62169u;
+    return (word >> 11u) ^ word;
+}
+
+inline uint32_t pcg_output_rxs_m_xs_32_32(uint32_t state)
+{
+    uint32_t word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+    return (word >> 22u) ^ word;
+}
+
+inline uint64_t pcg_output_rxs_m_xs_64_64(uint64_t state)
+{
+    uint64_t word = ((state >> ((state >> 59u) + 5u)) ^ state)
+                    * 12605985483714917081ull;
+    return (word >> 43u) ^ word;
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_output_rxs_m_xs_128_128(pcg128_t state)
+{
+    pcg128_t word = ((state >> ((state >> 122u) + 6u)) ^ state)
+                       * (PCG_128BIT_CONSTANT(17766728186571221404ULL,
+                                              12605985483714917081ULL));
+    // 327738287884841127335028083622016905945
+    return (word >> 86u) ^ word;
+}
+#endif
+
+// XSL RR (only defined for >= 64 bits)
+
+inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state)
+{
+    return pcg_rotr_32(((uint32_t)(state >> 32u)) ^ (uint32_t)state,
+                       state >> 59u);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state)
+{
+    return pcg_rotr_64(((uint64_t)(state >> 64u)) ^ (uint64_t)state,
+                       state >> 122u);
+}
+#endif
+
+// XSL RR RR (only defined for >= 64 bits)
+
+inline uint64_t pcg_output_xsl_rr_rr_64_64(uint64_t state)
+{
+    uint32_t rot1 = (uint32_t)(state >> 59u);
+    uint32_t high = (uint32_t)(state >> 32u);
+    uint32_t low  = (uint32_t)state;
+    uint32_t xored = high ^ low;
+    uint32_t newlow  = pcg_rotr_32(xored, rot1);
+    uint32_t newhigh = pcg_rotr_32(high, newlow & 31u);
+    return (((uint64_t)newhigh) << 32u) | newlow;
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_output_xsl_rr_rr_128_128(pcg128_t state)
+{
+    uint32_t rot1 = (uint32_t)(state >> 122u);
+    uint64_t high = (uint64_t)(state >> 64u);
+    uint64_t low  = (uint64_t)state;
+    uint64_t xored = high ^ low;
+    uint64_t newlow  = pcg_rotr_64(xored, rot1);
+    uint64_t newhigh = pcg_rotr_64(high, newlow & 63u);
+    return (((pcg128_t)newhigh) << 64u) | newlow;
+}
+#endif
+
+#define PCG_DEFAULT_MULTIPLIER_8   141U
+#define PCG_DEFAULT_MULTIPLIER_16  12829U
+#define PCG_DEFAULT_MULTIPLIER_32  747796405U
+#define PCG_DEFAULT_MULTIPLIER_64  6364136223846793005ULL
+
+#define PCG_DEFAULT_INCREMENT_8    77U
+#define PCG_DEFAULT_INCREMENT_16   47989U
+#define PCG_DEFAULT_INCREMENT_32   2891336453U
+#define PCG_DEFAULT_INCREMENT_64   1442695040888963407ULL
+
+#if PCG_HAS_128BIT_OPS
+#define PCG_DEFAULT_MULTIPLIER_128 \
+        PCG_128BIT_CONSTANT(2549297995355413924ULL,4865540595714422341ULL)
+#define PCG_DEFAULT_INCREMENT_128  \
+        PCG_128BIT_CONSTANT(6364136223846793005ULL,1442695040888963407ULL)
+#endif
+
+/*
+ * Static initialization constants (if you can't call srandom for some
+ * bizarre reason).
+ */
+
+#define PCG_STATE_ONESEQ_8_INITIALIZER      { 0xd7U }
+#define PCG_STATE_ONESEQ_16_INITIALIZER     { 0x20dfU }
+#define PCG_STATE_ONESEQ_32_INITIALIZER     { 0x46b56677U }
+#define PCG_STATE_ONESEQ_64_INITIALIZER     { 0x4d595df4d0f33173ULL }
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_ONESEQ_128_INITIALIZER                                       \
+    { PCG_128BIT_CONSTANT(0xb8dc10e158a92392ULL, 0x98046df007ec0a53ULL) }
+#endif
+
+#define PCG_STATE_UNIQUE_8_INITIALIZER      PCG_STATE_ONESEQ_8_INITIALIZER
+#define PCG_STATE_UNIQUE_16_INITIALIZER     PCG_STATE_ONESEQ_16_INITIALIZER
+#define PCG_STATE_UNIQUE_32_INITIALIZER     PCG_STATE_ONESEQ_32_INITIALIZER
+#define PCG_STATE_UNIQUE_64_INITIALIZER     PCG_STATE_ONESEQ_64_INITIALIZER
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_UNIQUE_128_INITIALIZER    PCG_STATE_ONESEQ_128_INITIALIZER
+#endif
+
+#define PCG_STATE_MCG_8_INITIALIZER         { 0xe5U }
+#define PCG_STATE_MCG_16_INITIALIZER        { 0xa5e5U }
+#define PCG_STATE_MCG_32_INITIALIZER        { 0xd15ea5e5U }
+#define PCG_STATE_MCG_64_INITIALIZER        { 0xcafef00dd15ea5e5ULL }
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_MCG_128_INITIALIZER                                          \
+    { PCG_128BIT_CONSTANT(0x0000000000000000ULL, 0xcafef00dd15ea5e5ULL) }
+#endif
+
+#define PCG_STATE_SETSEQ_8_INITIALIZER      { 0x9bU, 0xdbU }
+#define PCG_STATE_SETSEQ_16_INITIALIZER     { 0xe39bU, 0x5bdbU }
+#define PCG_STATE_SETSEQ_32_INITIALIZER     { 0xec02d89bU, 0x94b95bdbU }
+#define PCG_STATE_SETSEQ_64_INITIALIZER                                        \
+    { 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL }
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_SETSEQ_128_INITIALIZER                                       \
+    { PCG_128BIT_CONSTANT(0x979c9a98d8462005ULL, 0x7d3e9cb6cfe0549bULL),       \
+      PCG_128BIT_CONSTANT(0x0000000000000001ULL, 0xda3e39cb94b95bdbULL) }
+#endif
+
+/* Representations for the oneseq, mcg, and unique variants */
+
+struct pcg_state_8 {
+    uint8_t state;
+};
+
+struct pcg_state_16 {
+    uint16_t state;
+};
+
+struct pcg_state_32 {
+    uint32_t state;
+};
+
+struct pcg_state_64 {
+    uint64_t state;
+};
+
+#if PCG_HAS_128BIT_OPS
+struct pcg_state_128 {
+    pcg128_t state;
+};
+#endif
+
+/* Representations setseq variants */
+
+struct pcg_state_setseq_8 {
+    uint8_t state;
+    uint8_t inc;
+};
+
+struct pcg_state_setseq_16 {
+    uint16_t state;
+    uint16_t inc;
+};
+
+struct pcg_state_setseq_32 {
+    uint32_t state;
+    uint32_t inc;
+};
+
+struct pcg_state_setseq_64 {
+    uint64_t state;
+    uint64_t inc;
+};
+
+#if PCG_HAS_128BIT_OPS
+struct pcg_state_setseq_128 {
+    pcg128_t state;
+    pcg128_t inc;
+};
+#endif
+
+/* Multi-step advance functions (jump-ahead, jump-back) */
+
+extern uint8_t pcg_advance_lcg_8(uint8_t state, uint8_t delta, uint8_t cur_mult,
+                                 uint8_t cur_plus);
+extern uint16_t pcg_advance_lcg_16(uint16_t state, uint16_t delta,
+                                   uint16_t cur_mult, uint16_t cur_plus);
+extern uint32_t pcg_advance_lcg_32(uint32_t state, uint32_t delta,
+                                   uint32_t cur_mult, uint32_t cur_plus);
+extern uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta,
+                                   uint64_t cur_mult, uint64_t cur_plus);
+
+#if PCG_HAS_128BIT_OPS
+extern pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta,
+                                    pcg128_t cur_mult, pcg128_t cur_plus);
+#endif
+
+/* Functions to advance the underlying LCG, one version for each size and
+ * each style.  These functions are considered semi-private.  There is rarely
+ * a good reason to call them directly.
+ */
+
+inline void pcg_oneseq_8_step_r(struct pcg_state_8* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8
+                 + PCG_DEFAULT_INCREMENT_8;
+}
+
+inline void pcg_oneseq_8_advance_r(struct pcg_state_8* rng, uint8_t delta)
+{
+    rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8,
+                                   PCG_DEFAULT_INCREMENT_8);
+}
+
+inline void pcg_mcg_8_step_r(struct pcg_state_8* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8;
+}
+
+inline void pcg_mcg_8_advance_r(struct pcg_state_8* rng, uint8_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, 0u);
+}
+
+inline void pcg_unique_8_step_r(struct pcg_state_8* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8
+                 + (uint8_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_8_advance_r(struct pcg_state_8* rng, uint8_t delta)
+{
+    rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8,
+                                   (uint8_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_8_step_r(struct pcg_state_setseq_8* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8 + rng->inc;
+}
+
+inline void pcg_setseq_8_advance_r(struct pcg_state_setseq_8* rng,
+                                   uint8_t delta)
+{
+    rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8,
+                                   rng->inc);
+}
+
+inline void pcg_oneseq_16_step_r(struct pcg_state_16* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16
+                 + PCG_DEFAULT_INCREMENT_16;
+}
+
+inline void pcg_oneseq_16_advance_r(struct pcg_state_16* rng, uint16_t delta)
+{
+    rng->state = pcg_advance_lcg_16(
+        rng->state, delta, PCG_DEFAULT_MULTIPLIER_16, PCG_DEFAULT_INCREMENT_16);
+}
+
+inline void pcg_mcg_16_step_r(struct pcg_state_16* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16;
+}
+
+inline void pcg_mcg_16_advance_r(struct pcg_state_16* rng, uint16_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16, 0u);
+}
+
+inline void pcg_unique_16_step_r(struct pcg_state_16* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16
+                 + (uint16_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_16_advance_r(struct pcg_state_16* rng, uint16_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16,
+                             (uint16_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_16_step_r(struct pcg_state_setseq_16* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16 + rng->inc;
+}
+
+inline void pcg_setseq_16_advance_r(struct pcg_state_setseq_16* rng,
+                                    uint16_t delta)
+{
+    rng->state = pcg_advance_lcg_16(rng->state, delta,
+                                    PCG_DEFAULT_MULTIPLIER_16, rng->inc);
+}
+
+inline void pcg_oneseq_32_step_r(struct pcg_state_32* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32
+                 + PCG_DEFAULT_INCREMENT_32;
+}
+
+inline void pcg_oneseq_32_advance_r(struct pcg_state_32* rng, uint32_t delta)
+{
+    rng->state = pcg_advance_lcg_32(
+        rng->state, delta, PCG_DEFAULT_MULTIPLIER_32, PCG_DEFAULT_INCREMENT_32);
+}
+
+inline void pcg_mcg_32_step_r(struct pcg_state_32* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32;
+}
+
+inline void pcg_mcg_32_advance_r(struct pcg_state_32* rng, uint32_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32, 0u);
+}
+
+inline void pcg_unique_32_step_r(struct pcg_state_32* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32
+                 + (uint32_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_32_advance_r(struct pcg_state_32* rng, uint32_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32,
+                             (uint32_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_32_step_r(struct pcg_state_setseq_32* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32 + rng->inc;
+}
+
+inline void pcg_setseq_32_advance_r(struct pcg_state_setseq_32* rng,
+                                    uint32_t delta)
+{
+    rng->state = pcg_advance_lcg_32(rng->state, delta,
+                                    PCG_DEFAULT_MULTIPLIER_32, rng->inc);
+}
+
+inline void pcg_oneseq_64_step_r(struct pcg_state_64* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64
+                 + PCG_DEFAULT_INCREMENT_64;
+}
+
+inline void pcg_oneseq_64_advance_r(struct pcg_state_64* rng, uint64_t delta)
+{
+    rng->state = pcg_advance_lcg_64(
+        rng->state, delta, PCG_DEFAULT_MULTIPLIER_64, PCG_DEFAULT_INCREMENT_64);
+}
+
+inline void pcg_mcg_64_step_r(struct pcg_state_64* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64;
+}
+
+inline void pcg_mcg_64_advance_r(struct pcg_state_64* rng, uint64_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64, 0u);
+}
+
+inline void pcg_unique_64_step_r(struct pcg_state_64* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64
+                 + (uint64_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_64_advance_r(struct pcg_state_64* rng, uint64_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64,
+                             (uint64_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_64_step_r(struct pcg_state_setseq_64* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 + rng->inc;
+}
+
+inline void pcg_setseq_64_advance_r(struct pcg_state_setseq_64* rng,
+                                    uint64_t delta)
+{
+    rng->state = pcg_advance_lcg_64(rng->state, delta,
+                                    PCG_DEFAULT_MULTIPLIER_64, rng->inc);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_oneseq_128_step_r(struct pcg_state_128* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128
+                 + PCG_DEFAULT_INCREMENT_128;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_oneseq_128_advance_r(struct pcg_state_128* rng, pcg128_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_128(rng->state, delta, PCG_DEFAULT_MULTIPLIER_128,
+                              PCG_DEFAULT_INCREMENT_128);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_mcg_128_step_r(struct pcg_state_128* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_mcg_128_advance_r(struct pcg_state_128* rng, pcg128_t delta)
+{
+    rng->state = pcg_advance_lcg_128(rng->state, delta,
+                                     PCG_DEFAULT_MULTIPLIER_128, 0u);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_unique_128_step_r(struct pcg_state_128* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128
+                 + (pcg128_t)(((intptr_t)rng) | 1u);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_unique_128_advance_r(struct pcg_state_128* rng, pcg128_t delta)
+{
+    rng->state
+        = pcg_advance_lcg_128(rng->state, delta, PCG_DEFAULT_MULTIPLIER_128,
+                              (pcg128_t)(((intptr_t)rng) | 1u));
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_setseq_128_step_r(struct pcg_state_setseq_128* rng)
+{
+    rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 + rng->inc;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_setseq_128_advance_r(struct pcg_state_setseq_128* rng,
+                                     pcg128_t delta)
+{
+    rng->state = pcg_advance_lcg_128(rng->state, delta,
+                                     PCG_DEFAULT_MULTIPLIER_128, rng->inc);
+}
+#endif
+
+/* Functions to seed the RNG state, one version for each size and each
+ * style.  Unlike the step functions, regular users can and should call
+ * these functions.
+ */
+
+inline void pcg_oneseq_8_srandom_r(struct pcg_state_8* rng, uint8_t initstate)
+{
+    rng->state = 0U;
+    pcg_oneseq_8_step_r(rng);
+    rng->state += initstate;
+    pcg_oneseq_8_step_r(rng);
+}
+
+inline void pcg_mcg_8_srandom_r(struct pcg_state_8* rng, uint8_t initstate)
+{
+    rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_8_srandom_r(struct pcg_state_8* rng, uint8_t initstate)
+{
+    rng->state = 0U;
+    pcg_unique_8_step_r(rng);
+    rng->state += initstate;
+    pcg_unique_8_step_r(rng);
+}
+
+inline void pcg_setseq_8_srandom_r(struct pcg_state_setseq_8* rng,
+                                   uint8_t initstate, uint8_t initseq)
+{
+    rng->state = 0U;
+    rng->inc = (initseq << 1u) | 1u;
+    pcg_setseq_8_step_r(rng);
+    rng->state += initstate;
+    pcg_setseq_8_step_r(rng);
+}
+
+inline void pcg_oneseq_16_srandom_r(struct pcg_state_16* rng,
+                                    uint16_t initstate)
+{
+    rng->state = 0U;
+    pcg_oneseq_16_step_r(rng);
+    rng->state += initstate;
+    pcg_oneseq_16_step_r(rng);
+}
+
+inline void pcg_mcg_16_srandom_r(struct pcg_state_16* rng, uint16_t initstate)
+{
+    rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_16_srandom_r(struct pcg_state_16* rng,
+                                    uint16_t initstate)
+{
+    rng->state = 0U;
+    pcg_unique_16_step_r(rng);
+    rng->state += initstate;
+    pcg_unique_16_step_r(rng);
+}
+
+inline void pcg_setseq_16_srandom_r(struct pcg_state_setseq_16* rng,
+                                    uint16_t initstate, uint16_t initseq)
+{
+    rng->state = 0U;
+    rng->inc = (initseq << 1u) | 1u;
+    pcg_setseq_16_step_r(rng);
+    rng->state += initstate;
+    pcg_setseq_16_step_r(rng);
+}
+
+inline void pcg_oneseq_32_srandom_r(struct pcg_state_32* rng,
+                                    uint32_t initstate)
+{
+    rng->state = 0U;
+    pcg_oneseq_32_step_r(rng);
+    rng->state += initstate;
+    pcg_oneseq_32_step_r(rng);
+}
+
+inline void pcg_mcg_32_srandom_r(struct pcg_state_32* rng, uint32_t initstate)
+{
+    rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_32_srandom_r(struct pcg_state_32* rng,
+                                    uint32_t initstate)
+{
+    rng->state = 0U;
+    pcg_unique_32_step_r(rng);
+    rng->state += initstate;
+    pcg_unique_32_step_r(rng);
+}
+
+inline void pcg_setseq_32_srandom_r(struct pcg_state_setseq_32* rng,
+                                    uint32_t initstate, uint32_t initseq)
+{
+    rng->state = 0U;
+    rng->inc = (initseq << 1u) | 1u;
+    pcg_setseq_32_step_r(rng);
+    rng->state += initstate;
+    pcg_setseq_32_step_r(rng);
+}
+
+inline void pcg_oneseq_64_srandom_r(struct pcg_state_64* rng,
+                                    uint64_t initstate)
+{
+    rng->state = 0U;
+    pcg_oneseq_64_step_r(rng);
+    rng->state += initstate;
+    pcg_oneseq_64_step_r(rng);
+}
+
+inline void pcg_mcg_64_srandom_r(struct pcg_state_64* rng, uint64_t initstate)
+{
+    rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_64_srandom_r(struct pcg_state_64* rng,
+                                    uint64_t initstate)
+{
+    rng->state = 0U;
+    pcg_unique_64_step_r(rng);
+    rng->state += initstate;
+    pcg_unique_64_step_r(rng);
+}
+
+inline void pcg_setseq_64_srandom_r(struct pcg_state_setseq_64* rng,
+                                    uint64_t initstate, uint64_t initseq)
+{
+    rng->state = 0U;
+    rng->inc = (initseq << 1u) | 1u;
+    pcg_setseq_64_step_r(rng);
+    rng->state += initstate;
+    pcg_setseq_64_step_r(rng);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_oneseq_128_srandom_r(struct pcg_state_128* rng,
+                                     pcg128_t initstate)
+{
+    rng->state = 0U;
+    pcg_oneseq_128_step_r(rng);
+    rng->state += initstate;
+    pcg_oneseq_128_step_r(rng);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_mcg_128_srandom_r(struct pcg_state_128* rng, pcg128_t initstate)
+{
+    rng->state = initstate | 1u;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_unique_128_srandom_r(struct pcg_state_128* rng,
+                                     pcg128_t initstate)
+{
+    rng->state = 0U;
+    pcg_unique_128_step_r(rng);
+    rng->state += initstate;
+    pcg_unique_128_step_r(rng);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_setseq_128_srandom_r(struct pcg_state_setseq_128* rng,
+                                     pcg128_t initstate, pcg128_t initseq)
+{
+    rng->state = 0U;
+    rng->inc = (initseq << 1u) | 1u;
+    pcg_setseq_128_step_r(rng);
+    rng->state += initstate;
+    pcg_setseq_128_step_r(rng);
+}
+#endif
+
+/* Now, finally we create each of the individual generators. We provide
+ * a random_r function that provides a random number of the appropriate
+ * type (using the full range of the type) and a boundedrand_r version
+ * that provides
+ *
+ * Implementation notes for boundedrand_r:
+ *
+ *     To avoid bias, we need to make the range of the RNG a multiple of
+ *     bound, which we do by dropping output less than a threshold.
+ *     Let's consider a 32-bit case...  A naive scheme to calculate the
+ *     threshold would be to do
+ *
+ *         uint32_t threshold = 0x100000000ull % bound;
+ *
+ *     but 64-bit div/mod is slower than 32-bit div/mod (especially on
+ *     32-bit platforms).  In essence, we do
+ *
+ *         uint32_t threshold = (0x100000000ull-bound) % bound;
+ *
+ *     because this version will calculate the same modulus, but the LHS
+ *     value is less than 2^32.
+ *
+ *     (Note that using modulo is only wise for good RNGs, poorer RNGs
+ *     such as raw LCGs do better using a technique based on division.)
+ *     Empricical tests show that division is preferable to modulus for
+ *     reducting the range of an RNG.  It's faster, and sometimes it can
+ *     even be statistically prefereable.
+ */
+
+/* Generation functions for XSH RS */
+
+inline uint8_t pcg_oneseq_16_xsh_rs_8_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_oneseq_16_step_r(rng);
+    return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t pcg_oneseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng,
+                                                    uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_oneseq_16_xsh_rs_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rs_16_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_oneseq_32_step_r(rng);
+    return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng,
+                                                      uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_oneseq_32_xsh_rs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rs_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_oneseq_64_step_r(rng);
+    return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng,
+                                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_oneseq_64_xsh_rs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_oneseq_128_xsh_rs_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_oneseq_128_step_r(rng);
+    return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_oneseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_oneseq_128_xsh_rs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_unique_16_xsh_rs_8_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_unique_16_step_r(rng);
+    return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t pcg_unique_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng,
+                                                    uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_unique_16_xsh_rs_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_unique_32_xsh_rs_16_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_unique_32_step_r(rng);
+    return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t pcg_unique_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng,
+                                                      uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_unique_32_xsh_rs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_unique_64_xsh_rs_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_unique_64_step_r(rng);
+    return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t pcg_unique_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng,
+                                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_unique_64_xsh_rs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_unique_128_xsh_rs_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_unique_128_step_r(rng);
+    return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_unique_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_unique_128_xsh_rs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_setseq_16_xsh_rs_8_random_r(struct pcg_state_setseq_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_setseq_16_step_r(rng);
+    return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t
+pcg_setseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_setseq_16* rng,
+                                     uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_setseq_16_xsh_rs_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rs_16_random_r(struct pcg_state_setseq_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_setseq_32_step_r(rng);
+    return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_setseq_32* rng,
+                                      uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_setseq_32_xsh_rs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rs_32_random_r(struct pcg_state_setseq_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_setseq_64_step_r(rng);
+    return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_setseq_64* rng,
+                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_setseq_64_xsh_rs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rs_64_random_r(struct pcg_state_setseq_128* rng)
+{
+    pcg_setseq_128_step_r(rng);
+    return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_setseq_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_setseq_128_xsh_rs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_mcg_16_xsh_rs_8_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_mcg_16_step_r(rng);
+    return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t pcg_mcg_16_xsh_rs_8_boundedrand_r(struct pcg_state_16* rng,
+                                                 uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_mcg_16_xsh_rs_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_mcg_32_xsh_rs_16_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_mcg_32_step_r(rng);
+    return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t pcg_mcg_32_xsh_rs_16_boundedrand_r(struct pcg_state_32* rng,
+                                                   uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_mcg_32_xsh_rs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_mcg_64_xsh_rs_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_mcg_64_step_r(rng);
+    return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t pcg_mcg_64_xsh_rs_32_boundedrand_r(struct pcg_state_64* rng,
+                                                   uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_mcg_64_xsh_rs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rs_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_mcg_128_step_r(rng);
+    return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rs_64_boundedrand_r(struct pcg_state_128* rng,
+                                                    uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_mcg_128_xsh_rs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+/* Generation functions for XSH RR */
+
+inline uint8_t pcg_oneseq_16_xsh_rr_8_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_oneseq_16_step_r(rng);
+    return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t pcg_oneseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng,
+                                                    uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_oneseq_16_xsh_rr_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rr_16_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_oneseq_32_step_r(rng);
+    return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng,
+                                                      uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_oneseq_32_xsh_rr_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rr_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_oneseq_64_step_r(rng);
+    return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng,
+                                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_oneseq_64_xsh_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_oneseq_128_xsh_rr_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_oneseq_128_step_r(rng);
+    return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_oneseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_oneseq_128_xsh_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_unique_16_xsh_rr_8_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_unique_16_step_r(rng);
+    return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t pcg_unique_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng,
+                                                    uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_unique_16_xsh_rr_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_unique_32_xsh_rr_16_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_unique_32_step_r(rng);
+    return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t pcg_unique_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng,
+                                                      uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_unique_32_xsh_rr_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_unique_64_xsh_rr_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_unique_64_step_r(rng);
+    return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_unique_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng,
+                                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_unique_64_xsh_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_unique_128_xsh_rr_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_unique_128_step_r(rng);
+    return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_unique_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_unique_128_xsh_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_setseq_16_xsh_rr_8_random_r(struct pcg_state_setseq_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_setseq_16_step_r(rng);
+    return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t
+pcg_setseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_setseq_16* rng,
+                                     uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_setseq_16_xsh_rr_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rr_16_random_r(struct pcg_state_setseq_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_setseq_32_step_r(rng);
+    return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_setseq_32* rng,
+                                      uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_setseq_32_xsh_rr_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rr_32_random_r(struct pcg_state_setseq_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_setseq_64_step_r(rng);
+    return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_setseq_64* rng,
+                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_setseq_64_xsh_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rr_64_random_r(struct pcg_state_setseq_128* rng)
+{
+    pcg_setseq_128_step_r(rng);
+    return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_setseq_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_setseq_128_xsh_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_mcg_16_xsh_rr_8_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_mcg_16_step_r(rng);
+    return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t pcg_mcg_16_xsh_rr_8_boundedrand_r(struct pcg_state_16* rng,
+                                                 uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_mcg_16_xsh_rr_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_mcg_32_xsh_rr_16_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_mcg_32_step_r(rng);
+    return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t pcg_mcg_32_xsh_rr_16_boundedrand_r(struct pcg_state_32* rng,
+                                                   uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_mcg_32_xsh_rr_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_mcg_64_xsh_rr_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_mcg_64_step_r(rng);
+    return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_mcg_64_xsh_rr_32_boundedrand_r(struct pcg_state_64* rng,
+                                                   uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_mcg_64_xsh_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rr_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_mcg_128_step_r(rng);
+    return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rr_64_boundedrand_r(struct pcg_state_128* rng,
+                                                    uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_mcg_128_xsh_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+/* Generation functions for RXS M XS (no MCG versions because they
+ * don't make sense when you want to use the entire state)
+ */
+
+inline uint8_t pcg_oneseq_8_rxs_m_xs_8_random_r(struct pcg_state_8* rng)
+{
+    uint8_t oldstate = rng->state;
+    pcg_oneseq_8_step_r(rng);
+    return pcg_output_rxs_m_xs_8_8(oldstate);
+}
+
+inline uint8_t pcg_oneseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_8* rng,
+                                                     uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_oneseq_8_rxs_m_xs_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t pcg_oneseq_16_rxs_m_xs_16_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_oneseq_16_step_r(rng);
+    return pcg_output_rxs_m_xs_16_16(oldstate);
+}
+
+inline uint16_t
+pcg_oneseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng,
+                                        uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_oneseq_16_rxs_m_xs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_oneseq_32_rxs_m_xs_32_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_oneseq_32_step_r(rng);
+    return pcg_output_rxs_m_xs_32_32(oldstate);
+}
+
+inline uint32_t
+pcg_oneseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32* rng,
+                                        uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_oneseq_32_rxs_m_xs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint64_t pcg_oneseq_64_rxs_m_xs_64_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_oneseq_64_step_r(rng);
+    return pcg_output_rxs_m_xs_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_oneseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64* rng,
+                                        uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_oneseq_64_rxs_m_xs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_oneseq_128_rxs_m_xs_128_random_r(struct pcg_state_128* rng)
+{
+    pcg_oneseq_128_step_r(rng);
+    return pcg_output_rxs_m_xs_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_oneseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128* rng,
+                                          pcg128_t bound)
+{
+    pcg128_t threshold = -bound % bound;
+    for (;;) {
+        pcg128_t r = pcg_oneseq_128_rxs_m_xs_128_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint16_t pcg_unique_16_rxs_m_xs_16_random_r(struct pcg_state_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_unique_16_step_r(rng);
+    return pcg_output_rxs_m_xs_16_16(oldstate);
+}
+
+inline uint16_t
+pcg_unique_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16* rng,
+                                        uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_unique_16_rxs_m_xs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t pcg_unique_32_rxs_m_xs_32_random_r(struct pcg_state_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_unique_32_step_r(rng);
+    return pcg_output_rxs_m_xs_32_32(oldstate);
+}
+
+inline uint32_t
+pcg_unique_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32* rng,
+                                        uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_unique_32_rxs_m_xs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint64_t pcg_unique_64_rxs_m_xs_64_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_unique_64_step_r(rng);
+    return pcg_output_rxs_m_xs_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_unique_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64* rng,
+                                        uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_unique_64_rxs_m_xs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_unique_128_rxs_m_xs_128_random_r(struct pcg_state_128* rng)
+{
+    pcg_unique_128_step_r(rng);
+    return pcg_output_rxs_m_xs_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_unique_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128* rng,
+                                          pcg128_t bound)
+{
+    pcg128_t threshold = -bound % bound;
+    for (;;) {
+        pcg128_t r = pcg_unique_128_rxs_m_xs_128_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint8_t pcg_setseq_8_rxs_m_xs_8_random_r(struct pcg_state_setseq_8* rng)
+{
+    uint8_t oldstate = rng->state;
+    pcg_setseq_8_step_r(rng);
+    return pcg_output_rxs_m_xs_8_8(oldstate);
+}
+
+inline uint8_t
+pcg_setseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_setseq_8* rng,
+                                      uint8_t bound)
+{
+    uint8_t threshold = ((uint8_t)(-bound)) % bound;
+    for (;;) {
+        uint8_t r = pcg_setseq_8_rxs_m_xs_8_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint16_t
+pcg_setseq_16_rxs_m_xs_16_random_r(struct pcg_state_setseq_16* rng)
+{
+    uint16_t oldstate = rng->state;
+    pcg_setseq_16_step_r(rng);
+    return pcg_output_rxs_m_xs_16_16(oldstate);
+}
+
+inline uint16_t
+pcg_setseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_setseq_16* rng,
+                                        uint16_t bound)
+{
+    uint16_t threshold = ((uint16_t)(-bound)) % bound;
+    for (;;) {
+        uint16_t r = pcg_setseq_16_rxs_m_xs_16_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint32_t
+pcg_setseq_32_rxs_m_xs_32_random_r(struct pcg_state_setseq_32* rng)
+{
+    uint32_t oldstate = rng->state;
+    pcg_setseq_32_step_r(rng);
+    return pcg_output_rxs_m_xs_32_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_setseq_32* rng,
+                                        uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_setseq_32_rxs_m_xs_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+inline uint64_t
+pcg_setseq_64_rxs_m_xs_64_random_r(struct pcg_state_setseq_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_setseq_64_step_r(rng);
+    return pcg_output_rxs_m_xs_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_setseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_setseq_64* rng,
+                                        uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_setseq_64_rxs_m_xs_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_rxs_m_xs_128_random_r(struct pcg_state_setseq_128* rng)
+{
+    pcg_setseq_128_step_r(rng);
+    return pcg_output_rxs_m_xs_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_setseq_128* rng,
+                                          pcg128_t bound)
+{
+    pcg128_t threshold = -bound % bound;
+    for (;;) {
+        pcg128_t r = pcg_setseq_128_rxs_m_xs_128_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+/* Generation functions for XSL RR (only defined for "large" types) */
+
+inline uint32_t pcg_oneseq_64_xsl_rr_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_oneseq_64_step_r(rng);
+    return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_oneseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng,
+                                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_oneseq_64_xsl_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_oneseq_128_xsl_rr_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_oneseq_128_step_r(rng);
+    return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_oneseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_oneseq_128_xsl_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint32_t pcg_unique_64_xsl_rr_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_unique_64_step_r(rng);
+    return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_unique_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng,
+                                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_unique_64_xsl_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_unique_128_xsl_rr_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_unique_128_step_r(rng);
+    return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_unique_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_unique_128_xsl_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint32_t
+pcg_setseq_64_xsl_rr_32_random_r(struct pcg_state_setseq_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_setseq_64_step_r(rng);
+    return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_setseq_64* rng,
+                                      uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_setseq_64_xsl_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsl_rr_64_random_r(struct pcg_state_setseq_128* rng)
+{
+    pcg_setseq_128_step_r(rng);
+    return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_setseq_128* rng,
+                                       uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_setseq_128_xsl_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint32_t pcg_mcg_64_xsl_rr_32_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_mcg_64_step_r(rng);
+    return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_mcg_64_xsl_rr_32_boundedrand_r(struct pcg_state_64* rng,
+                                                   uint32_t bound)
+{
+    uint32_t threshold = -bound % bound;
+    for (;;) {
+        uint32_t r = pcg_mcg_64_xsl_rr_32_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsl_rr_64_random_r(struct pcg_state_128* rng)
+{
+    pcg_mcg_128_step_r(rng);
+    return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsl_rr_64_boundedrand_r(struct pcg_state_128* rng,
+                                                    uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_mcg_128_xsl_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+/* Generation functions for XSL RR RR (only defined for "large" types) */
+
+inline uint64_t pcg_oneseq_64_xsl_rr_rr_64_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_oneseq_64_step_r(rng);
+    return pcg_output_xsl_rr_rr_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_oneseq_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_64* rng,
+                                         uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_oneseq_64_xsl_rr_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_oneseq_128_xsl_rr_rr_128_random_r(struct pcg_state_128* rng)
+{
+    pcg_oneseq_128_step_r(rng);
+    return pcg_output_xsl_rr_rr_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_oneseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128* rng,
+                                           pcg128_t bound)
+{
+    pcg128_t threshold = -bound % bound;
+    for (;;) {
+        pcg128_t r = pcg_oneseq_128_xsl_rr_rr_128_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint64_t pcg_unique_64_xsl_rr_rr_64_random_r(struct pcg_state_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_unique_64_step_r(rng);
+    return pcg_output_xsl_rr_rr_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_unique_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_64* rng,
+                                         uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_unique_64_xsl_rr_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_unique_128_xsl_rr_rr_128_random_r(struct pcg_state_128* rng)
+{
+    pcg_unique_128_step_r(rng);
+    return pcg_output_xsl_rr_rr_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_unique_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128* rng,
+                                           pcg128_t bound)
+{
+    pcg128_t threshold = -bound % bound;
+    for (;;) {
+        pcg128_t r = pcg_unique_128_xsl_rr_rr_128_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+inline uint64_t
+pcg_setseq_64_xsl_rr_rr_64_random_r(struct pcg_state_setseq_64* rng)
+{
+    uint64_t oldstate = rng->state;
+    pcg_setseq_64_step_r(rng);
+    return pcg_output_xsl_rr_rr_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_setseq_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_setseq_64* rng,
+                                         uint64_t bound)
+{
+    uint64_t threshold = -bound % bound;
+    for (;;) {
+        uint64_t r = pcg_setseq_64_xsl_rr_rr_64_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_xsl_rr_rr_128_random_r(struct pcg_state_setseq_128* rng)
+{
+    pcg_setseq_128_step_r(rng);
+    return pcg_output_xsl_rr_rr_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_setseq_128* rng,
+                                           pcg128_t bound)
+{
+    pcg128_t threshold = -bound % bound;
+    for (;;) {
+        pcg128_t r = pcg_setseq_128_xsl_rr_rr_128_random_r(rng);
+        if (r >= threshold)
+            return r % bound;
+    }
+}
+#endif
+
+//// Typedefs
+typedef struct pcg_state_setseq_64      pcg32_random_t;
+typedef struct pcg_state_64             pcg32s_random_t;
+typedef struct pcg_state_64             pcg32u_random_t;
+typedef struct pcg_state_64             pcg32f_random_t;
+//// random_r
+#define pcg32_random_r                  pcg_setseq_64_xsh_rr_32_random_r
+#define pcg32s_random_r                 pcg_oneseq_64_xsh_rr_32_random_r
+#define pcg32u_random_r                 pcg_unique_64_xsh_rr_32_random_r
+#define pcg32f_random_r                 pcg_mcg_64_xsh_rs_32_random_r
+//// boundedrand_r
+#define pcg32_boundedrand_r             pcg_setseq_64_xsh_rr_32_boundedrand_r
+#define pcg32s_boundedrand_r            pcg_oneseq_64_xsh_rr_32_boundedrand_r
+#define pcg32u_boundedrand_r            pcg_unique_64_xsh_rr_32_boundedrand_r
+#define pcg32f_boundedrand_r            pcg_mcg_64_xsh_rs_32_boundedrand_r
+//// srandom_r
+#define pcg32_srandom_r                 pcg_setseq_64_srandom_r
+#define pcg32s_srandom_r                pcg_oneseq_64_srandom_r
+#define pcg32u_srandom_r                pcg_unique_64_srandom_r
+#define pcg32f_srandom_r                pcg_mcg_64_srandom_r
+//// advance_r
+#define pcg32_advance_r                 pcg_setseq_64_advance_r
+#define pcg32s_advance_r                pcg_oneseq_64_advance_r
+#define pcg32u_advance_r                pcg_unique_64_advance_r
+#define pcg32f_advance_r                pcg_mcg_64_advance_r
+
+#if PCG_HAS_128BIT_OPS
+//// Typedefs
+typedef struct pcg_state_setseq_128     pcg64_random_t;
+typedef struct pcg_state_128            pcg64s_random_t;
+typedef struct pcg_state_128            pcg64u_random_t;
+typedef struct pcg_state_128            pcg64f_random_t;
+//// random_r
+#define pcg64_random_r                  pcg_setseq_128_xsl_rr_64_random_r
+#define pcg64s_random_r                 pcg_oneseq_128_xsl_rr_64_random_r
+#define pcg64u_random_r                 pcg_unique_128_xsl_rr_64_random_r
+#define pcg64f_random_r                 pcg_mcg_128_xsl_rr_64_random_r
+//// boundedrand_r
+#define pcg64_boundedrand_r             pcg_setseq_128_xsl_rr_64_boundedrand_r
+#define pcg64s_boundedrand_r            pcg_oneseq_128_xsl_rr_64_boundedrand_r
+#define pcg64u_boundedrand_r            pcg_unique_128_xsl_rr_64_boundedrand_r
+#define pcg64f_boundedrand_r            pcg_mcg_128_xsl_rr_64_boundedrand_r
+//// srandom_r
+#define pcg64_srandom_r                 pcg_setseq_128_srandom_r
+#define pcg64s_srandom_r                pcg_oneseq_128_srandom_r
+#define pcg64u_srandom_r                pcg_unique_128_srandom_r
+#define pcg64f_srandom_r                pcg_mcg_128_srandom_r
+//// advance_r
+#define pcg64_advance_r                 pcg_setseq_128_advance_r
+#define pcg64s_advance_r                pcg_oneseq_128_advance_r
+#define pcg64u_advance_r                pcg_unique_128_advance_r
+#define pcg64f_advance_r                pcg_mcg_128_advance_r
+#endif
+
+//// Typedefs
+typedef struct pcg_state_8              pcg8si_random_t;
+typedef struct pcg_state_16             pcg16si_random_t;
+typedef struct pcg_state_32             pcg32si_random_t;
+typedef struct pcg_state_64             pcg64si_random_t;
+//// random_r
+#define pcg8si_random_r                 pcg_oneseq_8_rxs_m_xs_8_random_r
+#define pcg16si_random_r                pcg_oneseq_16_rxs_m_xs_16_random_r
+#define pcg32si_random_r                pcg_oneseq_32_rxs_m_xs_32_random_r
+#define pcg64si_random_r                pcg_oneseq_64_rxs_m_xs_64_random_r
+//// boundedrand_r
+#define pcg8si_boundedrand_r            pcg_oneseq_8_rxs_m_xs_8_boundedrand_r
+#define pcg16si_boundedrand_r           pcg_oneseq_16_rxs_m_xs_16_boundedrand_r
+#define pcg32si_boundedrand_r           pcg_oneseq_32_rxs_m_xs_32_boundedrand_r
+#define pcg64si_boundedrand_r           pcg_oneseq_64_rxs_m_xs_64_boundedrand_r
+//// srandom_r
+#define pcg8si_srandom_r                pcg_oneseq_8_srandom_r
+#define pcg16si_srandom_r               pcg_oneseq_16_srandom_r
+#define pcg32si_srandom_r               pcg_oneseq_32_srandom_r
+#define pcg64si_srandom_r               pcg_oneseq_64_srandom_r
+//// advance_r
+#define pcg8si_advance_r                pcg_oneseq_8_advance_r
+#define pcg16si_advance_r               pcg_oneseq_16_advance_r
+#define pcg32si_advance_r               pcg_oneseq_32_advance_r
+#define pcg64si_advance_r               pcg_oneseq_64_advance_r
+
+#if PCG_HAS_128BIT_OPS
+typedef struct pcg_state_128        pcg128si_random_t;
+#define pcg128si_random_r           pcg_oneseq_128_rxs_m_xs_128_random_r
+#define pcg128si_boundedrand_r      pcg_oneseq_128_rxs_m_xs_128_boundedrand_r
+#define pcg128si_srandom_r          pcg_oneseq_128_srandom_r
+#define pcg128si_advance_r          pcg_oneseq_128_advance_r
+#endif
+
+//// Typedefs
+typedef struct pcg_state_setseq_8       pcg8i_random_t;
+typedef struct pcg_state_setseq_16      pcg16i_random_t;
+typedef struct pcg_state_setseq_32      pcg32i_random_t;
+typedef struct pcg_state_setseq_64      pcg64i_random_t;
+//// random_r
+#define pcg8i_random_r                  pcg_setseq_8_rxs_m_xs_8_random_r
+#define pcg16i_random_r                 pcg_setseq_16_rxs_m_xs_16_random_r
+#define pcg32i_random_r                 pcg_setseq_32_rxs_m_xs_32_random_r
+#define pcg64i_random_r                 pcg_setseq_64_rxs_m_xs_64_random_r
+//// boundedrand_r
+#define pcg8i_boundedrand_r             pcg_setseq_8_rxs_m_xs_8_boundedrand_r
+#define pcg16i_boundedrand_r            pcg_setseq_16_rxs_m_xs_16_boundedrand_r
+#define pcg32i_boundedrand_r            pcg_setseq_32_rxs_m_xs_32_boundedrand_r
+#define pcg64i_boundedrand_r            pcg_setseq_64_rxs_m_xs_64_boundedrand_r
+//// srandom_r
+#define pcg8i_srandom_r                 pcg_setseq_8_srandom_r
+#define pcg16i_srandom_r                pcg_setseq_16_srandom_r
+#define pcg32i_srandom_r                pcg_setseq_32_srandom_r
+#define pcg64i_srandom_r                pcg_setseq_64_srandom_r
+//// advance_r
+#define pcg8i_advance_r                 pcg_setseq_8_advance_r
+#define pcg16i_advance_r                pcg_setseq_16_advance_r
+#define pcg32i_advance_r                pcg_setseq_32_advance_r
+#define pcg64i_advance_r                pcg_setseq_64_advance_r
+
+#if PCG_HAS_128BIT_OPS
+typedef struct pcg_state_setseq_128   pcg128i_random_t;
+#define pcg128i_random_r              pcg_setseq_128_rxs_m_xs_128_random_r
+#define pcg128i_boundedrand_r         pcg_setseq_128_rxs_m_xs_128_boundedrand_r
+#define pcg128i_srandom_r             pcg_setseq_128_srandom_r
+#define pcg128i_advance_r             pcg_setseq_128_advance_r
+#endif
+
+extern uint32_t pcg32_random();
+extern uint32_t pcg32_boundedrand(uint32_t bound);
+extern void     pcg32_srandom(uint64_t seed, uint64_t seq);
+extern void     pcg32_advance(uint64_t delta);
+
+#if PCG_HAS_128BIT_OPS
+extern uint64_t pcg64_random();
+extern uint64_t pcg64_boundedrand(uint64_t bound);
+extern void     pcg64_srandom(pcg128_t seed, pcg128_t seq);
+extern void     pcg64_advance(pcg128_t delta);
+#endif
+
+/*
+ * Static initialization constants (if you can't call srandom for some
+ * bizarre reason).
+ */
+
+#define PCG32_INITIALIZER       PCG_STATE_SETSEQ_64_INITIALIZER
+#define PCG32U_INITIALIZER      PCG_STATE_UNIQUE_64_INITIALIZER
+#define PCG32S_INITIALIZER      PCG_STATE_ONESEQ_64_INITIALIZER
+#define PCG32F_INITIALIZER      PCG_STATE_MCG_64_INITIALIZER
+
+#if PCG_HAS_128BIT_OPS
+#define PCG64_INITIALIZER       PCG_STATE_SETSEQ_128_INITIALIZER
+#define PCG64U_INITIALIZER      PCG_STATE_UNIQUE_128_INITIALIZER
+#define PCG64S_INITIALIZER      PCG_STATE_ONESEQ_128_INITIALIZER
+#define PCG64F_INITIALIZER      PCG_STATE_MCG_128_INITIALIZER
+#endif
+
+#define PCG8SI_INITIALIZER      PCG_STATE_ONESEQ_8_INITIALIZER
+#define PCG16SI_INITIALIZER     PCG_STATE_ONESEQ_16_INITIALIZER
+#define PCG32SI_INITIALIZER     PCG_STATE_ONESEQ_32_INITIALIZER
+#define PCG64SI_INITIALIZER     PCG_STATE_ONESEQ_64_INITIALIZER
+#if PCG_HAS_128BIT_OPS
+#define PCG128SI_INITIALIZER    PCG_STATE_ONESEQ_128_INITIALIZER
+#endif
+
+#define PCG8I_INITIALIZER       PCG_STATE_SETSEQ_8_INITIALIZER
+#define PCG16I_INITIALIZER      PCG_STATE_SETSEQ_16_INITIALIZER
+#define PCG32I_INITIALIZER      PCG_STATE_SETSEQ_32_INITIALIZER
+#define PCG64I_INITIALIZER      PCG_STATE_SETSEQ_64_INITIALIZER
+#if PCG_HAS_128BIT_OPS
+#define PCG128I_INITIALIZER     PCG_STATE_SETSEQ_128_INITIALIZER
+#endif
+
+#if __cplusplus
+}
+#endif
+
+#endif // PCG_VARIANTS_H_INCLUDED
diff --git a/numpy/random/src/pcg64/LICENSE.md b/numpy/random/src/pcg64/LICENSE.md
new file mode 100644
index 000000000..dd6a17ee8
--- /dev/null
+++ b/numpy/random/src/pcg64/LICENSE.md
@@ -0,0 +1,22 @@
+# PCG64
+
+PCG Random Number Generation for C.
+
+Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+For additional information about the PCG random number generation scheme,
+including its license and other licensing options, visit
+
+ http://www.pcg-random.org
diff --git a/numpy/random/src/pcg64/pcg64-benchmark.c b/numpy/random/src/pcg64/pcg64-benchmark.c
new file mode 100644
index 000000000..76f3ec78c
--- /dev/null
+++ b/numpy/random/src/pcg64/pcg64-benchmark.c
@@ -0,0 +1,42 @@
+/*
+ * cl pcg64-benchmark.c pcg64.c ../splitmix64/splitmix64.c /Ox
+ * Measure-Command { .\xoroshiro128-benchmark.exe }
+ *
+ * gcc pcg64-benchmark.c pcg64.c ../splitmix64/splitmix64.c -O3 -o
+ * pcg64-benchmark
+ * time ./pcg64-benchmark
+ */
+#include "../splitmix64/splitmix64.h"
+#include "pcg64.h"
+#include <inttypes.h>
+#include <stdio.h>
+#include <time.h>
+
+#define N 1000000000
+
+int main() {
+  pcg64_random_t rng;
+  uint64_t sum = 0, count = 0;
+  uint64_t seed = 0xDEADBEAF;
+  int i;
+#if __SIZEOF_INT128__ && !defined(PCG_FORCE_EMULATED_128BIT_MATH)
+  rng.state = (__uint128_t)splitmix64_next(&seed) << 64;
+  rng.state |= splitmix64_next(&seed);
+  rng.inc = (__uint128_t)1;
+#else
+  rng.state.high = splitmix64_next(&seed);
+  rng.state.low = splitmix64_next(&seed);
+  rng.inc.high = 0;
+  rng.inc.low = 1;
+#endif
+  clock_t begin = clock();
+  for (i = 0; i < N; i++) {
+    sum += pcg64_random_r(&rng);
+    count++;
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(N / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/pcg64/pcg64-test-data-gen.c b/numpy/random/src/pcg64/pcg64-test-data-gen.c
new file mode 100644
index 000000000..0c2b079a3
--- /dev/null
+++ b/numpy/random/src/pcg64/pcg64-test-data-gen.c
@@ -0,0 +1,73 @@
+/*
+ * Generate testing csv files
+ *
+ * GCC only
+ *
+ * gcc  pcg64-test-data-gen.c pcg64.orig.c ../splitmix64/splitmix64.c -o
+ * pgc64-test-data-gen
+ */
+
+#include "pcg64.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  pcg64_random_t rng;
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  __uint128_t temp, s, inc;
+  int i;
+  uint64_t store[N];
+  s = (__uint128_t)seed;
+  inc = (__uint128_t)0;
+  pcg64_srandom_r(&rng, s, inc);
+  printf("0x%" PRIx64, (uint64_t)(rng.state >> 64));
+  printf("%" PRIx64 "\n", (uint64_t)rng.state);
+  printf("0x%" PRIx64, (uint64_t)(rng.inc >> 64));
+  printf("%" PRIx64 "\n", (uint64_t)rng.inc);
+  for (i = 0; i < N; i++) {
+    store[i] = pcg64_random_r(&rng);
+  }
+
+  FILE *fp;
+  fp = fopen("pcg64-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  state = seed = 0;
+  s = (__uint128_t)seed;
+  i = (__uint128_t)0;
+  pcg64_srandom_r(&rng, s, i);
+  printf("0x%" PRIx64, (uint64_t)(rng.state >> 64));
+  printf("%" PRIx64 "\n", (uint64_t)rng.state);
+  printf("0x%" PRIx64, (uint64_t)(rng.inc >> 64));
+  printf("%" PRIx64 "\n", (uint64_t)rng.inc);
+  for (i = 0; i < N; i++) {
+    store[i] = pcg64_random_r(&rng);
+  }
+  fp = fopen("pcg64-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/pcg64/pcg64.c b/numpy/random/src/pcg64/pcg64.c
new file mode 100644
index 000000000..c7c1eb045
--- /dev/null
+++ b/numpy/random/src/pcg64/pcg64.c
@@ -0,0 +1,118 @@
+/*
+ * PCG64 Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ * Copyright 2015 Robert Kern <robert.kern@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+#include "pcg64.h"
+
+extern inline void pcg_setseq_128_step_r(pcg_state_setseq_128 *rng);
+extern inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state);
+extern inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128 *rng,
+                                            pcg128_t initstate,
+                                            pcg128_t initseq);
+extern inline uint64_t
+pcg_setseq_128_xsl_rr_64_random_r(pcg_state_setseq_128 *rng);
+extern inline uint64_t
+pcg_setseq_128_xsl_rr_64_boundedrand_r(pcg_state_setseq_128 *rng,
+                                       uint64_t bound);
+extern inline void pcg_setseq_128_advance_r(pcg_state_setseq_128 *rng,
+                                            pcg128_t delta);
+
+/* Multi-step advance functions (jump-ahead, jump-back)
+ *
+ * The method used here is based on Brown, "Random Number Generation
+ * with Arbitrary Stride,", Transactions of the American Nuclear
+ * Society (Nov. 1994).  The algorithm is very similar to fast
+ * exponentiation.
+ *
+ * Even though delta is an unsigned integer, we can pass a
+ * signed integer to go backwards, it just goes "the long way round".
+ */
+
+#ifndef PCG_EMULATED_128BIT_MATH
+
+pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,
+                             pcg128_t cur_plus) {
+  pcg128_t acc_mult = 1u;
+  pcg128_t acc_plus = 0u;
+  while (delta > 0) {
+    if (delta & 1) {
+      acc_mult *= cur_mult;
+      acc_plus = acc_plus * cur_mult + cur_plus;
+    }
+    cur_plus = (cur_mult + 1) * cur_plus;
+    cur_mult *= cur_mult;
+    delta /= 2;
+  }
+  return acc_mult * state + acc_plus;
+}
+
+#else
+
+pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,
+                             pcg128_t cur_plus) {
+  pcg128_t acc_mult = PCG_128BIT_CONSTANT(0u, 1u);
+  pcg128_t acc_plus = PCG_128BIT_CONSTANT(0u, 0u);
+  while ((delta.high > 0) || (delta.low > 0)) {
+    if (delta.low & 1) {
+      acc_mult = _pcg128_mult(acc_mult, cur_mult);
+      acc_plus = _pcg128_add(_pcg128_mult(acc_plus, cur_mult), cur_plus);
+    }
+    cur_plus = _pcg128_mult(_pcg128_add(cur_mult, PCG_128BIT_CONSTANT(0u, 1u)),
+                            cur_plus);
+    cur_mult = _pcg128_mult(cur_mult, cur_mult);
+    delta.low >>= 1;
+    delta.low += delta.high & 1;
+    delta.high >>= 1;
+  }
+  return _pcg128_add(_pcg128_mult(acc_mult, state), acc_plus);
+}
+
+#endif
+
+extern inline uint64_t pcg64_next64(pcg64_state *state);
+extern inline uint32_t pcg64_next32(pcg64_state *state);
+
+extern void pcg64_advance(pcg64_state *state, uint64_t *step) {
+  pcg128_t delta;
+#if __SIZEOF_INT128__ && !defined(PCG_FORCE_EMULATED_128BIT_MATH)
+  delta = (((pcg128_t)step[0]) << 64) | step[1];
+#else
+  delta.high = step[0];
+  delta.low = step[1];
+#endif
+  pcg64_advance_r(state->pcg_state, delta);
+}
+
+extern void pcg64_set_seed(pcg64_state *state, uint64_t *seed, uint64_t *inc) {
+  pcg128_t s, i;
+#if __SIZEOF_INT128__ && !defined(PCG_FORCE_EMULATED_128BIT_MATH)
+  s = (((pcg128_t)seed[0]) << 64) | seed[1];
+  i = (((pcg128_t)inc[0]) << 64) | inc[1];
+#else
+  s.high = seed[0];
+  s.low = seed[1];
+  i.high = inc[0];
+  i.low = inc[1];
+#endif
+  pcg64_srandom_r(state->pcg_state, s, i);
+}
diff --git a/numpy/random/src/pcg64/pcg64.h b/numpy/random/src/pcg64/pcg64.h
new file mode 100644
index 000000000..156c73a36
--- /dev/null
+++ b/numpy/random/src/pcg64/pcg64.h
@@ -0,0 +1,241 @@
+/*
+ * PCG64 Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ * Copyright 2015 Robert Kern <robert.kern@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+#ifndef PCG64_H_INCLUDED
+#define PCG64_H_INCLUDED 1
+
+#ifdef _WIN32
+#ifndef _INTTYPES
+#include "../common/stdint.h"
+#endif
+#define inline __inline __forceinline
+#else
+#include <inttypes.h>
+#if _MSC_VER >= 1900 && _M_AMD64
+#include <intrin.h>
+#pragma intrinsic(_umul128)
+#endif
+#endif
+
+#if __GNUC_GNU_INLINE__ && !defined(__cplusplus)
+#error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.
+#endif
+
+#if __cplusplus
+extern "C" {
+#endif
+
+#if __SIZEOF_INT128__ && !defined(PCG_FORCE_EMULATED_128BIT_MATH)
+typedef __uint128_t pcg128_t;
+#define PCG_128BIT_CONSTANT(high, low) (((pcg128_t)(high) << 64) + low)
+#else
+typedef struct {
+  uint64_t high;
+  uint64_t low;
+} pcg128_t;
+
+static inline pcg128_t PCG_128BIT_CONSTANT(uint64_t high, uint64_t low) {
+  pcg128_t result;
+  result.high = high;
+  result.low = low;
+  return result;
+}
+
+#define PCG_EMULATED_128BIT_MATH 1
+#endif
+
+typedef struct { pcg128_t state; } pcg_state_128;
+
+typedef struct {
+  pcg128_t state;
+  pcg128_t inc;
+} pcg_state_setseq_128;
+
+#define PCG_DEFAULT_MULTIPLIER_128                                             \
+  PCG_128BIT_CONSTANT(2549297995355413924ULL, 4865540595714422341ULL)
+#define PCG_DEFAULT_INCREMENT_128                                              \
+  PCG_128BIT_CONSTANT(6364136223846793005ULL, 1442695040888963407ULL)
+#define PCG_STATE_SETSEQ_128_INITIALIZER                                       \
+  {                                                                            \
+    PCG_128BIT_CONSTANT(0x979c9a98d8462005ULL, 0x7d3e9cb6cfe0549bULL)          \
+    , PCG_128BIT_CONSTANT(0x0000000000000001ULL, 0xda3e39cb94b95bdbULL)        \
+  }
+
+static inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot) {
+  return (value >> rot) | (value << ((-rot) & 63));
+}
+
+#ifdef PCG_EMULATED_128BIT_MATH
+
+static inline pcg128_t _pcg128_add(pcg128_t a, pcg128_t b) {
+  pcg128_t result;
+
+  result.low = a.low + b.low;
+  result.high = a.high + b.high + (result.low < b.low);
+  return result;
+}
+
+static inline void _pcg_mult64(uint64_t x, uint64_t y, uint64_t *z1,
+                               uint64_t *z0) {
+
+#if defined _WIN32 && _MSC_VER >= 1900 && _M_AMD64
+    z0[0] = _umul128(x, y, z1);
+#else
+  uint64_t x0, x1, y0, y1;
+  uint64_t w0, w1, w2, t;
+  /* Lower 64 bits are straightforward clock-arithmetic. */
+  *z0 = x * y;
+
+  x0 = x & 0xFFFFFFFFULL;
+  x1 = x >> 32;
+  y0 = y & 0xFFFFFFFFULL;
+  y1 = y >> 32;
+  w0 = x0 * y0;
+  t = x1 * y0 + (w0 >> 32);
+  w1 = t & 0xFFFFFFFFULL;
+  w2 = t >> 32;
+  w1 += x0 * y1;
+  *z1 = x1 * y1 + w2 + (w1 >> 32);
+#endif
+
+}
+
+static inline pcg128_t _pcg128_mult(pcg128_t a, pcg128_t b) {
+  uint64_t h1;
+  pcg128_t result;
+
+  h1 = a.high * b.low + a.low * b.high;
+  _pcg_mult64(a.low, b.low, &(result.high), &(result.low));
+  result.high += h1;
+  return result;
+}
+
+static inline void pcg_setseq_128_step_r(pcg_state_setseq_128 *rng) {
+  rng->state = _pcg128_add(_pcg128_mult(rng->state, PCG_DEFAULT_MULTIPLIER_128),
+                           rng->inc);
+}
+
+static inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state) {
+  return pcg_rotr_64(state.high ^ state.low, state.high >> 58u);
+}
+
+static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128 *rng,
+                                            pcg128_t initstate,
+                                            pcg128_t initseq) {
+  rng->state = PCG_128BIT_CONSTANT(0ULL, 0ULL);
+  rng->inc.high = initseq.high << 1u;
+  rng->inc.high |= initseq.low & 0x800000000000ULL;
+  rng->inc.low = (initseq.low << 1u) | 1u;
+  pcg_setseq_128_step_r(rng);
+  rng->state = _pcg128_add(rng->state, initstate);
+  pcg_setseq_128_step_r(rng);
+}
+
+#else /* PCG_EMULATED_128BIT_MATH */
+
+static inline void pcg_setseq_128_step_r(pcg_state_setseq_128 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 + rng->inc;
+}
+
+static inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state) {
+  return pcg_rotr_64(((uint64_t)(state >> 64u)) ^ (uint64_t)state,
+                     state >> 122u);
+}
+
+static inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128 *rng,
+                                            pcg128_t initstate,
+                                            pcg128_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_128_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_128_step_r(rng);
+}
+
+#endif /* PCG_EMULATED_128BIT_MATH */
+
+static inline uint64_t
+pcg_setseq_128_xsl_rr_64_random_r(pcg_state_setseq_128 *rng) {
+  pcg_setseq_128_step_r(rng);
+  return pcg_output_xsl_rr_128_64(rng->state);
+}
+
+static inline uint64_t
+pcg_setseq_128_xsl_rr_64_boundedrand_r(pcg_state_setseq_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_setseq_128_xsl_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+extern pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta,
+                                    pcg128_t cur_mult, pcg128_t cur_plus);
+
+static inline void pcg_setseq_128_advance_r(pcg_state_setseq_128 *rng,
+                                            pcg128_t delta) {
+  rng->state = pcg_advance_lcg_128(rng->state, delta,
+                                   PCG_DEFAULT_MULTIPLIER_128, rng->inc);
+}
+
+typedef pcg_state_setseq_128 pcg64_random_t;
+#define pcg64_random_r pcg_setseq_128_xsl_rr_64_random_r
+#define pcg64_boundedrand_r pcg_setseq_128_xsl_rr_64_boundedrand_r
+#define pcg64_srandom_r pcg_setseq_128_srandom_r
+#define pcg64_advance_r pcg_setseq_128_advance_r
+#define PCG64_INITIALIZER PCG_STATE_SETSEQ_128_INITIALIZER
+
+#if __cplusplus
+}
+#endif
+
+typedef struct s_pcg64_state {
+  pcg64_random_t *pcg_state;
+  int has_uint32;
+  uint32_t uinteger;
+} pcg64_state;
+
+static inline uint64_t pcg64_next64(pcg64_state *state) {
+  return pcg64_random_r(state->pcg_state);
+}
+
+static inline uint32_t pcg64_next32(pcg64_state *state) {
+  uint64_t next;
+  if (state->has_uint32) {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = pcg64_random_r(state->pcg_state);
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
+
+void pcg64_advance(pcg64_state *state, uint64_t *step);
+
+void pcg64_set_seed(pcg64_state *state, uint64_t *seed, uint64_t *inc);
+
+#endif /* PCG64_H_INCLUDED */
diff --git a/numpy/random/src/pcg64/pcg64.orig.c b/numpy/random/src/pcg64/pcg64.orig.c
new file mode 100644
index 000000000..07e97e4b6
--- /dev/null
+++ b/numpy/random/src/pcg64/pcg64.orig.c
@@ -0,0 +1,11 @@
+#include "pcg64.orig.h"
+
+extern inline void pcg_setseq_128_srandom_r(pcg64_random_t *rng,
+                                            pcg128_t initstate,
+                                            pcg128_t initseq);
+
+extern uint64_t pcg_rotr_64(uint64_t value, unsigned int rot);
+extern inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state);
+extern void pcg_setseq_128_step_r(struct pcg_state_setseq_128 *rng);
+extern uint64_t
+pcg_setseq_128_xsl_rr_64_random_r(struct pcg_state_setseq_128 *rng);
diff --git a/numpy/random/src/pcg64/pcg64.orig.h b/numpy/random/src/pcg64/pcg64.orig.h
new file mode 100644
index 000000000..74be91f31
--- /dev/null
+++ b/numpy/random/src/pcg64/pcg64.orig.h
@@ -0,0 +1,2025 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+/*
+ * This code is derived from the canonical C++ PCG implementation, which
+ * has many additional features and is preferable if you can use C++ in
+ * your project.
+ *
+ * Much of the derivation was performed mechanically.  In particular, the
+ * output functions were generated by compiling the C++ output functions
+ * into LLVM bitcode and then transforming that using the LLVM C backend
+ * (from https://github.com/draperlaboratory/llvm-cbe), and then
+ * postprocessing and hand editing the output.
+ *
+ * Much of the remaining code was generated by C-preprocessor metaprogramming.
+ */
+
+#ifndef PCG_VARIANTS_H_INCLUDED
+#define PCG_VARIANTS_H_INCLUDED 1
+
+#include <inttypes.h>
+
+#if __SIZEOF_INT128__
+typedef __uint128_t pcg128_t;
+#define PCG_128BIT_CONSTANT(high, low) ((((pcg128_t)high) << 64) + low)
+#define PCG_HAS_128BIT_OPS 1
+#endif
+
+#if __GNUC_GNU_INLINE__ && !defined(__cplusplus)
+#error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.
+// We could instead use macros PCG_INLINE and PCG_EXTERN_INLINE
+// but better to just reject ancient C code.
+#endif
+
+#if __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Rotate helper functions.
+ */
+
+inline uint8_t pcg_rotr_8(uint8_t value, unsigned int rot) {
+/* Unfortunately, clang is kinda pathetic when it comes to properly
+ * recognizing idiomatic rotate code, so for clang we actually provide
+ * assembler directives (enabled with PCG_USE_INLINE_ASM).  Boo, hiss.
+ */
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__)
+  asm("rorb   %%cl, %0" : "=r"(value) : "0"(value), "c"(rot));
+  return value;
+#else
+  return (value >> rot) | (value << ((-rot) & 7));
+#endif
+}
+
+inline uint16_t pcg_rotr_16(uint16_t value, unsigned int rot) {
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__)
+  asm("rorw   %%cl, %0" : "=r"(value) : "0"(value), "c"(rot));
+  return value;
+#else
+  return (value >> rot) | (value << ((-rot) & 15));
+#endif
+}
+
+inline uint32_t pcg_rotr_32(uint32_t value, unsigned int rot) {
+#if PCG_USE_INLINE_ASM && __clang__ && (__x86_64__ || __i386__)
+  asm("rorl   %%cl, %0" : "=r"(value) : "0"(value), "c"(rot));
+  return value;
+#else
+  return (value >> rot) | (value << ((-rot) & 31));
+#endif
+}
+
+inline uint64_t pcg_rotr_64(uint64_t value, unsigned int rot) {
+#if 0 && PCG_USE_INLINE_ASM && __clang__ && __x86_64__
+    // For whatever reason, clang actually *does* generate rotq by
+    // itself, so we don't need this code.
+    asm ("rorq   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+#else
+  return (value >> rot) | (value << ((-rot) & 63));
+#endif
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_rotr_128(pcg128_t value, unsigned int rot) {
+  return (value >> rot) | (value << ((-rot) & 127));
+}
+#endif
+
+/*
+ * Output functions.  These are the core of the PCG generation scheme.
+ */
+
+// XSH RS
+
+inline uint8_t pcg_output_xsh_rs_16_8(uint16_t state) {
+  return (uint8_t)(((state >> 7u) ^ state) >> ((state >> 14u) + 3u));
+}
+
+inline uint16_t pcg_output_xsh_rs_32_16(uint32_t state) {
+  return (uint16_t)(((state >> 11u) ^ state) >> ((state >> 30u) + 11u));
+}
+
+inline uint32_t pcg_output_xsh_rs_64_32(uint64_t state) {
+
+  return (uint32_t)(((state >> 22u) ^ state) >> ((state >> 61u) + 22u));
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_output_xsh_rs_128_64(pcg128_t state) {
+  return (uint64_t)(((state >> 43u) ^ state) >> ((state >> 124u) + 45u));
+}
+#endif
+
+// XSH RR
+
+inline uint8_t pcg_output_xsh_rr_16_8(uint16_t state) {
+  return pcg_rotr_8(((state >> 5u) ^ state) >> 5u, state >> 13u);
+}
+
+inline uint16_t pcg_output_xsh_rr_32_16(uint32_t state) {
+  return pcg_rotr_16(((state >> 10u) ^ state) >> 12u, state >> 28u);
+}
+
+inline uint32_t pcg_output_xsh_rr_64_32(uint64_t state) {
+  return pcg_rotr_32(((state >> 18u) ^ state) >> 27u, state >> 59u);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_output_xsh_rr_128_64(pcg128_t state) {
+  return pcg_rotr_64(((state >> 29u) ^ state) >> 58u, state >> 122u);
+}
+#endif
+
+// RXS M XS
+
+inline uint8_t pcg_output_rxs_m_xs_8_8(uint8_t state) {
+  uint8_t word = ((state >> ((state >> 6u) + 2u)) ^ state) * 217u;
+  return (word >> 6u) ^ word;
+}
+
+inline uint16_t pcg_output_rxs_m_xs_16_16(uint16_t state) {
+  uint16_t word = ((state >> ((state >> 13u) + 3u)) ^ state) * 62169u;
+  return (word >> 11u) ^ word;
+}
+
+inline uint32_t pcg_output_rxs_m_xs_32_32(uint32_t state) {
+  uint32_t word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+  return (word >> 22u) ^ word;
+}
+
+inline uint64_t pcg_output_rxs_m_xs_64_64(uint64_t state) {
+  uint64_t word =
+      ((state >> ((state >> 59u) + 5u)) ^ state) * 12605985483714917081ull;
+  return (word >> 43u) ^ word;
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_output_rxs_m_xs_128_128(pcg128_t state) {
+  pcg128_t word =
+      ((state >> ((state >> 122u) + 6u)) ^ state) *
+      (PCG_128BIT_CONSTANT(17766728186571221404ULL, 12605985483714917081ULL));
+  // 327738287884841127335028083622016905945
+  return (word >> 86u) ^ word;
+}
+#endif
+
+// XSL RR (only defined for >= 64 bits)
+
+inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state) {
+  return pcg_rotr_32(((uint32_t)(state >> 32u)) ^ (uint32_t)state,
+                     state >> 59u);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state) {
+  return pcg_rotr_64(((uint64_t)(state >> 64u)) ^ (uint64_t)state,
+                     state >> 122u);
+}
+#endif
+
+// XSL RR RR (only defined for >= 64 bits)
+
+inline uint64_t pcg_output_xsl_rr_rr_64_64(uint64_t state) {
+  uint32_t rot1 = (uint32_t)(state >> 59u);
+  uint32_t high = (uint32_t)(state >> 32u);
+  uint32_t low = (uint32_t)state;
+  uint32_t xored = high ^ low;
+  uint32_t newlow = pcg_rotr_32(xored, rot1);
+  uint32_t newhigh = pcg_rotr_32(high, newlow & 31u);
+  return (((uint64_t)newhigh) << 32u) | newlow;
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t pcg_output_xsl_rr_rr_128_128(pcg128_t state) {
+  uint32_t rot1 = (uint32_t)(state >> 122u);
+  uint64_t high = (uint64_t)(state >> 64u);
+  uint64_t low = (uint64_t)state;
+  uint64_t xored = high ^ low;
+  uint64_t newlow = pcg_rotr_64(xored, rot1);
+  uint64_t newhigh = pcg_rotr_64(high, newlow & 63u);
+  return (((pcg128_t)newhigh) << 64u) | newlow;
+}
+#endif
+
+#define PCG_DEFAULT_MULTIPLIER_8 141U
+#define PCG_DEFAULT_MULTIPLIER_16 12829U
+#define PCG_DEFAULT_MULTIPLIER_32 747796405U
+#define PCG_DEFAULT_MULTIPLIER_64 6364136223846793005ULL
+
+#define PCG_DEFAULT_INCREMENT_8 77U
+#define PCG_DEFAULT_INCREMENT_16 47989U
+#define PCG_DEFAULT_INCREMENT_32 2891336453U
+#define PCG_DEFAULT_INCREMENT_64 1442695040888963407ULL
+
+#if PCG_HAS_128BIT_OPS
+#define PCG_DEFAULT_MULTIPLIER_128                                             \
+  PCG_128BIT_CONSTANT(2549297995355413924ULL, 4865540595714422341ULL)
+#define PCG_DEFAULT_INCREMENT_128                                              \
+  PCG_128BIT_CONSTANT(6364136223846793005ULL, 1442695040888963407ULL)
+#endif
+
+  /*
+   * Static initialization constants (if you can't call srandom for some
+   * bizarre reason).
+   */
+
+#define PCG_STATE_ONESEQ_8_INITIALIZER                                         \
+  { 0xd7U }
+#define PCG_STATE_ONESEQ_16_INITIALIZER                                        \
+  { 0x20dfU }
+#define PCG_STATE_ONESEQ_32_INITIALIZER                                        \
+  { 0x46b56677U }
+#define PCG_STATE_ONESEQ_64_INITIALIZER                                        \
+  { 0x4d595df4d0f33173ULL }
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_ONESEQ_128_INITIALIZER                                       \
+  { PCG_128BIT_CONSTANT(0xb8dc10e158a92392ULL, 0x98046df007ec0a53ULL) }
+#endif
+
+#define PCG_STATE_UNIQUE_8_INITIALIZER PCG_STATE_ONESEQ_8_INITIALIZER
+#define PCG_STATE_UNIQUE_16_INITIALIZER PCG_STATE_ONESEQ_16_INITIALIZER
+#define PCG_STATE_UNIQUE_32_INITIALIZER PCG_STATE_ONESEQ_32_INITIALIZER
+#define PCG_STATE_UNIQUE_64_INITIALIZER PCG_STATE_ONESEQ_64_INITIALIZER
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_UNIQUE_128_INITIALIZER PCG_STATE_ONESEQ_128_INITIALIZER
+#endif
+
+#define PCG_STATE_MCG_8_INITIALIZER                                            \
+  { 0xe5U }
+#define PCG_STATE_MCG_16_INITIALIZER                                           \
+  { 0xa5e5U }
+#define PCG_STATE_MCG_32_INITIALIZER                                           \
+  { 0xd15ea5e5U }
+#define PCG_STATE_MCG_64_INITIALIZER                                           \
+  { 0xcafef00dd15ea5e5ULL }
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_MCG_128_INITIALIZER                                          \
+  { PCG_128BIT_CONSTANT(0x0000000000000000ULL, 0xcafef00dd15ea5e5ULL) }
+#endif
+
+#define PCG_STATE_SETSEQ_8_INITIALIZER                                         \
+  { 0x9bU, 0xdbU }
+#define PCG_STATE_SETSEQ_16_INITIALIZER                                        \
+  { 0xe39bU, 0x5bdbU }
+#define PCG_STATE_SETSEQ_32_INITIALIZER                                        \
+  { 0xec02d89bU, 0x94b95bdbU }
+#define PCG_STATE_SETSEQ_64_INITIALIZER                                        \
+  { 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL }
+#if PCG_HAS_128BIT_OPS
+#define PCG_STATE_SETSEQ_128_INITIALIZER                                       \
+  {                                                                            \
+    PCG_128BIT_CONSTANT(0x979c9a98d8462005ULL, 0x7d3e9cb6cfe0549bULL)          \
+    , PCG_128BIT_CONSTANT(0x0000000000000001ULL, 0xda3e39cb94b95bdbULL)        \
+  }
+#endif
+
+/* Representations for the oneseq, mcg, and unique variants */
+
+struct pcg_state_8 {
+  uint8_t state;
+};
+
+struct pcg_state_16 {
+  uint16_t state;
+};
+
+struct pcg_state_32 {
+  uint32_t state;
+};
+
+struct pcg_state_64 {
+  uint64_t state;
+};
+
+#if PCG_HAS_128BIT_OPS
+struct pcg_state_128 {
+  pcg128_t state;
+};
+#endif
+
+/* Representations setseq variants */
+
+struct pcg_state_setseq_8 {
+  uint8_t state;
+  uint8_t inc;
+};
+
+struct pcg_state_setseq_16 {
+  uint16_t state;
+  uint16_t inc;
+};
+
+struct pcg_state_setseq_32 {
+  uint32_t state;
+  uint32_t inc;
+};
+
+struct pcg_state_setseq_64 {
+  uint64_t state;
+  uint64_t inc;
+};
+
+#if PCG_HAS_128BIT_OPS
+struct pcg_state_setseq_128 {
+  pcg128_t state;
+  pcg128_t inc;
+};
+#endif
+
+/* Multi-step advance functions (jump-ahead, jump-back) */
+
+extern uint8_t pcg_advance_lcg_8(uint8_t state, uint8_t delta, uint8_t cur_mult,
+                                 uint8_t cur_plus);
+extern uint16_t pcg_advance_lcg_16(uint16_t state, uint16_t delta,
+                                   uint16_t cur_mult, uint16_t cur_plus);
+extern uint32_t pcg_advance_lcg_32(uint32_t state, uint32_t delta,
+                                   uint32_t cur_mult, uint32_t cur_plus);
+extern uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta,
+                                   uint64_t cur_mult, uint64_t cur_plus);
+
+#if PCG_HAS_128BIT_OPS
+extern pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta,
+                                    pcg128_t cur_mult, pcg128_t cur_plus);
+#endif
+
+/* Functions to advance the underlying LCG, one version for each size and
+ * each style.  These functions are considered semi-private.  There is rarely
+ * a good reason to call them directly.
+ */
+
+inline void pcg_oneseq_8_step_r(struct pcg_state_8 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8 + PCG_DEFAULT_INCREMENT_8;
+}
+
+inline void pcg_oneseq_8_advance_r(struct pcg_state_8 *rng, uint8_t delta) {
+  rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8,
+                                 PCG_DEFAULT_INCREMENT_8);
+}
+
+inline void pcg_mcg_8_step_r(struct pcg_state_8 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8;
+}
+
+inline void pcg_mcg_8_advance_r(struct pcg_state_8 *rng, uint8_t delta) {
+  rng->state =
+      pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, 0u);
+}
+
+inline void pcg_unique_8_step_r(struct pcg_state_8 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_8 + (uint8_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_8_advance_r(struct pcg_state_8 *rng, uint8_t delta) {
+  rng->state = pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8,
+                                 (uint8_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_8_step_r(struct pcg_state_setseq_8 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_8 + rng->inc;
+}
+
+inline void pcg_setseq_8_advance_r(struct pcg_state_setseq_8 *rng,
+                                   uint8_t delta) {
+  rng->state =
+      pcg_advance_lcg_8(rng->state, delta, PCG_DEFAULT_MULTIPLIER_8, rng->inc);
+}
+
+inline void pcg_oneseq_16_step_r(struct pcg_state_16 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_16 + PCG_DEFAULT_INCREMENT_16;
+}
+
+inline void pcg_oneseq_16_advance_r(struct pcg_state_16 *rng, uint16_t delta) {
+  rng->state = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16,
+                                  PCG_DEFAULT_INCREMENT_16);
+}
+
+inline void pcg_mcg_16_step_r(struct pcg_state_16 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16;
+}
+
+inline void pcg_mcg_16_advance_r(struct pcg_state_16 *rng, uint16_t delta) {
+  rng->state =
+      pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16, 0u);
+}
+
+inline void pcg_unique_16_step_r(struct pcg_state_16 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_16 + (uint16_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_16_advance_r(struct pcg_state_16 *rng, uint16_t delta) {
+  rng->state = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16,
+                                  (uint16_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_16_step_r(struct pcg_state_setseq_16 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_16 + rng->inc;
+}
+
+inline void pcg_setseq_16_advance_r(struct pcg_state_setseq_16 *rng,
+                                    uint16_t delta) {
+  rng->state = pcg_advance_lcg_16(rng->state, delta, PCG_DEFAULT_MULTIPLIER_16,
+                                  rng->inc);
+}
+
+inline void pcg_oneseq_32_step_r(struct pcg_state_32 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_32 + PCG_DEFAULT_INCREMENT_32;
+}
+
+inline void pcg_oneseq_32_advance_r(struct pcg_state_32 *rng, uint32_t delta) {
+  rng->state = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32,
+                                  PCG_DEFAULT_INCREMENT_32);
+}
+
+inline void pcg_mcg_32_step_r(struct pcg_state_32 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32;
+}
+
+inline void pcg_mcg_32_advance_r(struct pcg_state_32 *rng, uint32_t delta) {
+  rng->state =
+      pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32, 0u);
+}
+
+inline void pcg_unique_32_step_r(struct pcg_state_32 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_32 + (uint32_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_32_advance_r(struct pcg_state_32 *rng, uint32_t delta) {
+  rng->state = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32,
+                                  (uint32_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_32_step_r(struct pcg_state_setseq_32 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_32 + rng->inc;
+}
+
+inline void pcg_setseq_32_advance_r(struct pcg_state_setseq_32 *rng,
+                                    uint32_t delta) {
+  rng->state = pcg_advance_lcg_32(rng->state, delta, PCG_DEFAULT_MULTIPLIER_32,
+                                  rng->inc);
+}
+
+inline void pcg_oneseq_64_step_r(struct pcg_state_64 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_64 + PCG_DEFAULT_INCREMENT_64;
+}
+
+inline void pcg_oneseq_64_advance_r(struct pcg_state_64 *rng, uint64_t delta) {
+  rng->state = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64,
+                                  PCG_DEFAULT_INCREMENT_64);
+}
+
+inline void pcg_mcg_64_step_r(struct pcg_state_64 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64;
+}
+
+inline void pcg_mcg_64_advance_r(struct pcg_state_64 *rng, uint64_t delta) {
+  rng->state =
+      pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64, 0u);
+}
+
+inline void pcg_unique_64_step_r(struct pcg_state_64 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_64 + (uint64_t)(((intptr_t)rng) | 1u);
+}
+
+inline void pcg_unique_64_advance_r(struct pcg_state_64 *rng, uint64_t delta) {
+  rng->state = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64,
+                                  (uint64_t)(((intptr_t)rng) | 1u));
+}
+
+inline void pcg_setseq_64_step_r(struct pcg_state_setseq_64 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_64 + rng->inc;
+}
+
+inline void pcg_setseq_64_advance_r(struct pcg_state_setseq_64 *rng,
+                                    uint64_t delta) {
+  rng->state = pcg_advance_lcg_64(rng->state, delta, PCG_DEFAULT_MULTIPLIER_64,
+                                  rng->inc);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_oneseq_128_step_r(struct pcg_state_128 *rng) {
+  rng->state =
+      rng->state * PCG_DEFAULT_MULTIPLIER_128 + PCG_DEFAULT_INCREMENT_128;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_oneseq_128_advance_r(struct pcg_state_128 *rng,
+                                     pcg128_t delta) {
+  rng->state = pcg_advance_lcg_128(
+      rng->state, delta, PCG_DEFAULT_MULTIPLIER_128, PCG_DEFAULT_INCREMENT_128);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_mcg_128_step_r(struct pcg_state_128 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_mcg_128_advance_r(struct pcg_state_128 *rng, pcg128_t delta) {
+  rng->state =
+      pcg_advance_lcg_128(rng->state, delta, PCG_DEFAULT_MULTIPLIER_128, 0u);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_unique_128_step_r(struct pcg_state_128 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 +
+               (pcg128_t)(((intptr_t)rng) | 1u);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_unique_128_advance_r(struct pcg_state_128 *rng,
+                                     pcg128_t delta) {
+  rng->state =
+      pcg_advance_lcg_128(rng->state, delta, PCG_DEFAULT_MULTIPLIER_128,
+                          (pcg128_t)(((intptr_t)rng) | 1u));
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_setseq_128_step_r(struct pcg_state_setseq_128 *rng) {
+  rng->state = rng->state * PCG_DEFAULT_MULTIPLIER_128 + rng->inc;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_setseq_128_advance_r(struct pcg_state_setseq_128 *rng,
+                                     pcg128_t delta) {
+  rng->state = pcg_advance_lcg_128(rng->state, delta,
+                                   PCG_DEFAULT_MULTIPLIER_128, rng->inc);
+}
+#endif
+
+/* Functions to seed the RNG state, one version for each size and each
+ * style.  Unlike the step functions, regular users can and should call
+ * these functions.
+ */
+
+inline void pcg_oneseq_8_srandom_r(struct pcg_state_8 *rng, uint8_t initstate) {
+  rng->state = 0U;
+  pcg_oneseq_8_step_r(rng);
+  rng->state += initstate;
+  pcg_oneseq_8_step_r(rng);
+}
+
+inline void pcg_mcg_8_srandom_r(struct pcg_state_8 *rng, uint8_t initstate) {
+  rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_8_srandom_r(struct pcg_state_8 *rng, uint8_t initstate) {
+  rng->state = 0U;
+  pcg_unique_8_step_r(rng);
+  rng->state += initstate;
+  pcg_unique_8_step_r(rng);
+}
+
+inline void pcg_setseq_8_srandom_r(struct pcg_state_setseq_8 *rng,
+                                   uint8_t initstate, uint8_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_8_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_8_step_r(rng);
+}
+
+inline void pcg_oneseq_16_srandom_r(struct pcg_state_16 *rng,
+                                    uint16_t initstate) {
+  rng->state = 0U;
+  pcg_oneseq_16_step_r(rng);
+  rng->state += initstate;
+  pcg_oneseq_16_step_r(rng);
+}
+
+inline void pcg_mcg_16_srandom_r(struct pcg_state_16 *rng, uint16_t initstate) {
+  rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_16_srandom_r(struct pcg_state_16 *rng,
+                                    uint16_t initstate) {
+  rng->state = 0U;
+  pcg_unique_16_step_r(rng);
+  rng->state += initstate;
+  pcg_unique_16_step_r(rng);
+}
+
+inline void pcg_setseq_16_srandom_r(struct pcg_state_setseq_16 *rng,
+                                    uint16_t initstate, uint16_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_16_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_16_step_r(rng);
+}
+
+inline void pcg_oneseq_32_srandom_r(struct pcg_state_32 *rng,
+                                    uint32_t initstate) {
+  rng->state = 0U;
+  pcg_oneseq_32_step_r(rng);
+  rng->state += initstate;
+  pcg_oneseq_32_step_r(rng);
+}
+
+inline void pcg_mcg_32_srandom_r(struct pcg_state_32 *rng, uint32_t initstate) {
+  rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_32_srandom_r(struct pcg_state_32 *rng,
+                                    uint32_t initstate) {
+  rng->state = 0U;
+  pcg_unique_32_step_r(rng);
+  rng->state += initstate;
+  pcg_unique_32_step_r(rng);
+}
+
+inline void pcg_setseq_32_srandom_r(struct pcg_state_setseq_32 *rng,
+                                    uint32_t initstate, uint32_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_32_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_32_step_r(rng);
+}
+
+inline void pcg_oneseq_64_srandom_r(struct pcg_state_64 *rng,
+                                    uint64_t initstate) {
+  rng->state = 0U;
+  pcg_oneseq_64_step_r(rng);
+  rng->state += initstate;
+  pcg_oneseq_64_step_r(rng);
+}
+
+inline void pcg_mcg_64_srandom_r(struct pcg_state_64 *rng, uint64_t initstate) {
+  rng->state = initstate | 1u;
+}
+
+inline void pcg_unique_64_srandom_r(struct pcg_state_64 *rng,
+                                    uint64_t initstate) {
+  rng->state = 0U;
+  pcg_unique_64_step_r(rng);
+  rng->state += initstate;
+  pcg_unique_64_step_r(rng);
+}
+
+inline void pcg_setseq_64_srandom_r(struct pcg_state_setseq_64 *rng,
+                                    uint64_t initstate, uint64_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_64_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_64_step_r(rng);
+}
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_oneseq_128_srandom_r(struct pcg_state_128 *rng,
+                                     pcg128_t initstate) {
+  rng->state = 0U;
+  pcg_oneseq_128_step_r(rng);
+  rng->state += initstate;
+  pcg_oneseq_128_step_r(rng);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_mcg_128_srandom_r(struct pcg_state_128 *rng,
+                                  pcg128_t initstate) {
+  rng->state = initstate | 1u;
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_unique_128_srandom_r(struct pcg_state_128 *rng,
+                                     pcg128_t initstate) {
+  rng->state = 0U;
+  pcg_unique_128_step_r(rng);
+  rng->state += initstate;
+  pcg_unique_128_step_r(rng);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline void pcg_setseq_128_srandom_r(struct pcg_state_setseq_128 *rng,
+                                     pcg128_t initstate, pcg128_t initseq) {
+  rng->state = 0U;
+  rng->inc = (initseq << 1u) | 1u;
+  pcg_setseq_128_step_r(rng);
+  rng->state += initstate;
+  pcg_setseq_128_step_r(rng);
+}
+#endif
+
+/* Now, finally we create each of the individual generators. We provide
+ * a random_r function that provides a random number of the appropriate
+ * type (using the full range of the type) and a boundedrand_r version
+ * that provides
+ *
+ * Implementation notes for boundedrand_r:
+ *
+ *     To avoid bias, we need to make the range of the RNG a multiple of
+ *     bound, which we do by dropping output less than a threshold.
+ *     Let's consider a 32-bit case...  A naive scheme to calculate the
+ *     threshold would be to do
+ *
+ *         uint32_t threshold = 0x100000000ull % bound;
+ *
+ *     but 64-bit div/mod is slower than 32-bit div/mod (especially on
+ *     32-bit platforms).  In essence, we do
+ *
+ *         uint32_t threshold = (0x100000000ull-bound) % bound;
+ *
+ *     because this version will calculate the same modulus, but the LHS
+ *     value is less than 2^32.
+ *
+ *     (Note that using modulo is only wise for good RNGs, poorer RNGs
+ *     such as raw LCGs do better using a technique based on division.)
+ *     Empricical tests show that division is preferable to modulus for
+ *     reducting the range of an RNG.  It's faster, and sometimes it can
+ *     even be statistically prefereable.
+ */
+
+/* Generation functions for XSH RS */
+
+inline uint8_t pcg_oneseq_16_xsh_rs_8_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_oneseq_16_step_r(rng);
+  return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t pcg_oneseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_16 *rng,
+                                                    uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_oneseq_16_xsh_rs_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rs_16_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_oneseq_32_step_r(rng);
+  return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_32 *rng,
+                                                      uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_oneseq_32_xsh_rs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rs_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_oneseq_64_step_r(rng);
+  return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_oneseq_64_xsh_rs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_oneseq_128_xsh_rs_64_random_r(struct pcg_state_128 *rng) {
+  pcg_oneseq_128_step_r(rng);
+  return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_oneseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_oneseq_128_xsh_rs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t pcg_unique_16_xsh_rs_8_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_unique_16_step_r(rng);
+  return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t pcg_unique_16_xsh_rs_8_boundedrand_r(struct pcg_state_16 *rng,
+                                                    uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_unique_16_xsh_rs_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_unique_32_xsh_rs_16_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_unique_32_step_r(rng);
+  return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t pcg_unique_32_xsh_rs_16_boundedrand_r(struct pcg_state_32 *rng,
+                                                      uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_unique_32_xsh_rs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_unique_64_xsh_rs_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_unique_64_step_r(rng);
+  return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t pcg_unique_64_xsh_rs_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_unique_64_xsh_rs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_unique_128_xsh_rs_64_random_r(struct pcg_state_128 *rng) {
+  pcg_unique_128_step_r(rng);
+  return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_unique_128_xsh_rs_64_boundedrand_r(struct pcg_state_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_unique_128_xsh_rs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t
+pcg_setseq_16_xsh_rs_8_random_r(struct pcg_state_setseq_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_setseq_16_step_r(rng);
+  return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t
+pcg_setseq_16_xsh_rs_8_boundedrand_r(struct pcg_state_setseq_16 *rng,
+                                     uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_setseq_16_xsh_rs_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rs_16_random_r(struct pcg_state_setseq_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_setseq_32_step_r(rng);
+  return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rs_16_boundedrand_r(struct pcg_state_setseq_32 *rng,
+                                      uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_setseq_32_xsh_rs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rs_32_random_r(struct pcg_state_setseq_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_setseq_64_step_r(rng);
+  return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rs_32_boundedrand_r(struct pcg_state_setseq_64 *rng,
+                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_setseq_64_xsh_rs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rs_64_random_r(struct pcg_state_setseq_128 *rng) {
+  pcg_setseq_128_step_r(rng);
+  return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rs_64_boundedrand_r(struct pcg_state_setseq_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_setseq_128_xsh_rs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t pcg_mcg_16_xsh_rs_8_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_mcg_16_step_r(rng);
+  return pcg_output_xsh_rs_16_8(oldstate);
+}
+
+inline uint8_t pcg_mcg_16_xsh_rs_8_boundedrand_r(struct pcg_state_16 *rng,
+                                                 uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_mcg_16_xsh_rs_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_mcg_32_xsh_rs_16_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_mcg_32_step_r(rng);
+  return pcg_output_xsh_rs_32_16(oldstate);
+}
+
+inline uint16_t pcg_mcg_32_xsh_rs_16_boundedrand_r(struct pcg_state_32 *rng,
+                                                   uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_mcg_32_xsh_rs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_mcg_64_xsh_rs_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_mcg_64_step_r(rng);
+  return pcg_output_xsh_rs_64_32(oldstate);
+}
+
+inline uint32_t pcg_mcg_64_xsh_rs_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                   uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_mcg_64_xsh_rs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rs_64_random_r(struct pcg_state_128 *rng) {
+  pcg_mcg_128_step_r(rng);
+  return pcg_output_xsh_rs_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rs_64_boundedrand_r(struct pcg_state_128 *rng,
+                                                    uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_mcg_128_xsh_rs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+/* Generation functions for XSH RR */
+
+inline uint8_t pcg_oneseq_16_xsh_rr_8_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_oneseq_16_step_r(rng);
+  return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t pcg_oneseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_16 *rng,
+                                                    uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_oneseq_16_xsh_rr_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rr_16_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_oneseq_32_step_r(rng);
+  return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t pcg_oneseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_32 *rng,
+                                                      uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_oneseq_32_xsh_rr_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rr_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_oneseq_64_step_r(rng);
+  return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_oneseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_oneseq_64_xsh_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_oneseq_128_xsh_rr_64_random_r(struct pcg_state_128 *rng) {
+  pcg_oneseq_128_step_r(rng);
+  return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_oneseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_oneseq_128_xsh_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t pcg_unique_16_xsh_rr_8_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_unique_16_step_r(rng);
+  return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t pcg_unique_16_xsh_rr_8_boundedrand_r(struct pcg_state_16 *rng,
+                                                    uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_unique_16_xsh_rr_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_unique_32_xsh_rr_16_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_unique_32_step_r(rng);
+  return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t pcg_unique_32_xsh_rr_16_boundedrand_r(struct pcg_state_32 *rng,
+                                                      uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_unique_32_xsh_rr_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_unique_64_xsh_rr_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_unique_64_step_r(rng);
+  return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_unique_64_xsh_rr_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_unique_64_xsh_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_unique_128_xsh_rr_64_random_r(struct pcg_state_128 *rng) {
+  pcg_unique_128_step_r(rng);
+  return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_unique_128_xsh_rr_64_boundedrand_r(struct pcg_state_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_unique_128_xsh_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t
+pcg_setseq_16_xsh_rr_8_random_r(struct pcg_state_setseq_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_setseq_16_step_r(rng);
+  return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t
+pcg_setseq_16_xsh_rr_8_boundedrand_r(struct pcg_state_setseq_16 *rng,
+                                     uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_setseq_16_xsh_rr_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rr_16_random_r(struct pcg_state_setseq_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_setseq_32_step_r(rng);
+  return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t
+pcg_setseq_32_xsh_rr_16_boundedrand_r(struct pcg_state_setseq_32 *rng,
+                                      uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_setseq_32_xsh_rr_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rr_32_random_r(struct pcg_state_setseq_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_setseq_64_step_r(rng);
+  return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_64_xsh_rr_32_boundedrand_r(struct pcg_state_setseq_64 *rng,
+                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_setseq_64_xsh_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rr_64_random_r(struct pcg_state_setseq_128 *rng) {
+  pcg_setseq_128_step_r(rng);
+  return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsh_rr_64_boundedrand_r(struct pcg_state_setseq_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_setseq_128_xsh_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t pcg_mcg_16_xsh_rr_8_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_mcg_16_step_r(rng);
+  return pcg_output_xsh_rr_16_8(oldstate);
+}
+
+inline uint8_t pcg_mcg_16_xsh_rr_8_boundedrand_r(struct pcg_state_16 *rng,
+                                                 uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_mcg_16_xsh_rr_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_mcg_32_xsh_rr_16_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_mcg_32_step_r(rng);
+  return pcg_output_xsh_rr_32_16(oldstate);
+}
+
+inline uint16_t pcg_mcg_32_xsh_rr_16_boundedrand_r(struct pcg_state_32 *rng,
+                                                   uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_mcg_32_xsh_rr_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_mcg_64_xsh_rr_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_mcg_64_step_r(rng);
+  return pcg_output_xsh_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_mcg_64_xsh_rr_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                   uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_mcg_64_xsh_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rr_64_random_r(struct pcg_state_128 *rng) {
+  pcg_mcg_128_step_r(rng);
+  return pcg_output_xsh_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsh_rr_64_boundedrand_r(struct pcg_state_128 *rng,
+                                                    uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_mcg_128_xsh_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+/* Generation functions for RXS M XS (no MCG versions because they
+ * don't make sense when you want to use the entire state)
+ */
+
+inline uint8_t pcg_oneseq_8_rxs_m_xs_8_random_r(struct pcg_state_8 *rng) {
+  uint8_t oldstate = rng->state;
+  pcg_oneseq_8_step_r(rng);
+  return pcg_output_rxs_m_xs_8_8(oldstate);
+}
+
+inline uint8_t pcg_oneseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_8 *rng,
+                                                     uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_oneseq_8_rxs_m_xs_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t pcg_oneseq_16_rxs_m_xs_16_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_oneseq_16_step_r(rng);
+  return pcg_output_rxs_m_xs_16_16(oldstate);
+}
+
+inline uint16_t
+pcg_oneseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16 *rng,
+                                        uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_oneseq_16_rxs_m_xs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_oneseq_32_rxs_m_xs_32_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_oneseq_32_step_r(rng);
+  return pcg_output_rxs_m_xs_32_32(oldstate);
+}
+
+inline uint32_t
+pcg_oneseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32 *rng,
+                                        uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_oneseq_32_rxs_m_xs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint64_t pcg_oneseq_64_rxs_m_xs_64_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_oneseq_64_step_r(rng);
+  return pcg_output_rxs_m_xs_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_oneseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64 *rng,
+                                        uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_oneseq_64_rxs_m_xs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_oneseq_128_rxs_m_xs_128_random_r(struct pcg_state_128 *rng) {
+  pcg_oneseq_128_step_r(rng);
+  return pcg_output_rxs_m_xs_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_oneseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128 *rng,
+                                          pcg128_t bound) {
+  pcg128_t threshold = -bound % bound;
+  for (;;) {
+    pcg128_t r = pcg_oneseq_128_rxs_m_xs_128_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint16_t pcg_unique_16_rxs_m_xs_16_random_r(struct pcg_state_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_unique_16_step_r(rng);
+  return pcg_output_rxs_m_xs_16_16(oldstate);
+}
+
+inline uint16_t
+pcg_unique_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_16 *rng,
+                                        uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_unique_16_rxs_m_xs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t pcg_unique_32_rxs_m_xs_32_random_r(struct pcg_state_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_unique_32_step_r(rng);
+  return pcg_output_rxs_m_xs_32_32(oldstate);
+}
+
+inline uint32_t
+pcg_unique_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_32 *rng,
+                                        uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_unique_32_rxs_m_xs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint64_t pcg_unique_64_rxs_m_xs_64_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_unique_64_step_r(rng);
+  return pcg_output_rxs_m_xs_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_unique_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_64 *rng,
+                                        uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_unique_64_rxs_m_xs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_unique_128_rxs_m_xs_128_random_r(struct pcg_state_128 *rng) {
+  pcg_unique_128_step_r(rng);
+  return pcg_output_rxs_m_xs_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_unique_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_128 *rng,
+                                          pcg128_t bound) {
+  pcg128_t threshold = -bound % bound;
+  for (;;) {
+    pcg128_t r = pcg_unique_128_rxs_m_xs_128_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint8_t
+pcg_setseq_8_rxs_m_xs_8_random_r(struct pcg_state_setseq_8 *rng) {
+  uint8_t oldstate = rng->state;
+  pcg_setseq_8_step_r(rng);
+  return pcg_output_rxs_m_xs_8_8(oldstate);
+}
+
+inline uint8_t
+pcg_setseq_8_rxs_m_xs_8_boundedrand_r(struct pcg_state_setseq_8 *rng,
+                                      uint8_t bound) {
+  uint8_t threshold = ((uint8_t)(-bound)) % bound;
+  for (;;) {
+    uint8_t r = pcg_setseq_8_rxs_m_xs_8_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint16_t
+pcg_setseq_16_rxs_m_xs_16_random_r(struct pcg_state_setseq_16 *rng) {
+  uint16_t oldstate = rng->state;
+  pcg_setseq_16_step_r(rng);
+  return pcg_output_rxs_m_xs_16_16(oldstate);
+}
+
+inline uint16_t
+pcg_setseq_16_rxs_m_xs_16_boundedrand_r(struct pcg_state_setseq_16 *rng,
+                                        uint16_t bound) {
+  uint16_t threshold = ((uint16_t)(-bound)) % bound;
+  for (;;) {
+    uint16_t r = pcg_setseq_16_rxs_m_xs_16_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint32_t
+pcg_setseq_32_rxs_m_xs_32_random_r(struct pcg_state_setseq_32 *rng) {
+  uint32_t oldstate = rng->state;
+  pcg_setseq_32_step_r(rng);
+  return pcg_output_rxs_m_xs_32_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_32_rxs_m_xs_32_boundedrand_r(struct pcg_state_setseq_32 *rng,
+                                        uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_setseq_32_rxs_m_xs_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+inline uint64_t
+pcg_setseq_64_rxs_m_xs_64_random_r(struct pcg_state_setseq_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_setseq_64_step_r(rng);
+  return pcg_output_rxs_m_xs_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_setseq_64_rxs_m_xs_64_boundedrand_r(struct pcg_state_setseq_64 *rng,
+                                        uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_setseq_64_rxs_m_xs_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_rxs_m_xs_128_random_r(struct pcg_state_setseq_128 *rng) {
+  pcg_setseq_128_step_r(rng);
+  return pcg_output_rxs_m_xs_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_rxs_m_xs_128_boundedrand_r(struct pcg_state_setseq_128 *rng,
+                                          pcg128_t bound) {
+  pcg128_t threshold = -bound % bound;
+  for (;;) {
+    pcg128_t r = pcg_setseq_128_rxs_m_xs_128_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+/* Generation functions for XSL RR (only defined for "large" types) */
+
+inline uint32_t pcg_oneseq_64_xsl_rr_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_oneseq_64_step_r(rng);
+  return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_oneseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_oneseq_64_xsl_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_oneseq_128_xsl_rr_64_random_r(struct pcg_state_128 *rng) {
+  pcg_oneseq_128_step_r(rng);
+  return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_oneseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_oneseq_128_xsl_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint32_t pcg_unique_64_xsl_rr_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_unique_64_step_r(rng);
+  return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_unique_64_xsl_rr_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_unique_64_xsl_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_unique_128_xsl_rr_64_random_r(struct pcg_state_128 *rng) {
+  pcg_unique_128_step_r(rng);
+  return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_unique_128_xsl_rr_64_boundedrand_r(struct pcg_state_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_unique_128_xsl_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint32_t
+pcg_setseq_64_xsl_rr_32_random_r(struct pcg_state_setseq_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_setseq_64_step_r(rng);
+  return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t
+pcg_setseq_64_xsl_rr_32_boundedrand_r(struct pcg_state_setseq_64 *rng,
+                                      uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_setseq_64_xsl_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsl_rr_64_random_r(struct pcg_state_setseq_128 *rng) {
+  pcg_setseq_128_step_r(rng);
+  return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t
+pcg_setseq_128_xsl_rr_64_boundedrand_r(struct pcg_state_setseq_128 *rng,
+                                       uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_setseq_128_xsl_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint32_t pcg_mcg_64_xsl_rr_32_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_mcg_64_step_r(rng);
+  return pcg_output_xsl_rr_64_32(oldstate);
+}
+
+inline uint32_t pcg_mcg_64_xsl_rr_32_boundedrand_r(struct pcg_state_64 *rng,
+                                                   uint32_t bound) {
+  uint32_t threshold = -bound % bound;
+  for (;;) {
+    uint32_t r = pcg_mcg_64_xsl_rr_32_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsl_rr_64_random_r(struct pcg_state_128 *rng) {
+  pcg_mcg_128_step_r(rng);
+  return pcg_output_xsl_rr_128_64(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline uint64_t pcg_mcg_128_xsl_rr_64_boundedrand_r(struct pcg_state_128 *rng,
+                                                    uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_mcg_128_xsl_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+/* Generation functions for XSL RR RR (only defined for "large" types) */
+
+inline uint64_t pcg_oneseq_64_xsl_rr_rr_64_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_oneseq_64_step_r(rng);
+  return pcg_output_xsl_rr_rr_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_oneseq_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_64 *rng,
+                                         uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_oneseq_64_xsl_rr_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_oneseq_128_xsl_rr_rr_128_random_r(struct pcg_state_128 *rng) {
+  pcg_oneseq_128_step_r(rng);
+  return pcg_output_xsl_rr_rr_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_oneseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128 *rng,
+                                           pcg128_t bound) {
+  pcg128_t threshold = -bound % bound;
+  for (;;) {
+    pcg128_t r = pcg_oneseq_128_xsl_rr_rr_128_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint64_t pcg_unique_64_xsl_rr_rr_64_random_r(struct pcg_state_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_unique_64_step_r(rng);
+  return pcg_output_xsl_rr_rr_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_unique_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_64 *rng,
+                                         uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_unique_64_xsl_rr_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_unique_128_xsl_rr_rr_128_random_r(struct pcg_state_128 *rng) {
+  pcg_unique_128_step_r(rng);
+  return pcg_output_xsl_rr_rr_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_unique_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_128 *rng,
+                                           pcg128_t bound) {
+  pcg128_t threshold = -bound % bound;
+  for (;;) {
+    pcg128_t r = pcg_unique_128_xsl_rr_rr_128_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+inline uint64_t
+pcg_setseq_64_xsl_rr_rr_64_random_r(struct pcg_state_setseq_64 *rng) {
+  uint64_t oldstate = rng->state;
+  pcg_setseq_64_step_r(rng);
+  return pcg_output_xsl_rr_rr_64_64(oldstate);
+}
+
+inline uint64_t
+pcg_setseq_64_xsl_rr_rr_64_boundedrand_r(struct pcg_state_setseq_64 *rng,
+                                         uint64_t bound) {
+  uint64_t threshold = -bound % bound;
+  for (;;) {
+    uint64_t r = pcg_setseq_64_xsl_rr_rr_64_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_xsl_rr_rr_128_random_r(struct pcg_state_setseq_128 *rng) {
+  pcg_setseq_128_step_r(rng);
+  return pcg_output_xsl_rr_rr_128_128(rng->state);
+}
+#endif
+
+#if PCG_HAS_128BIT_OPS
+inline pcg128_t
+pcg_setseq_128_xsl_rr_rr_128_boundedrand_r(struct pcg_state_setseq_128 *rng,
+                                           pcg128_t bound) {
+  pcg128_t threshold = -bound % bound;
+  for (;;) {
+    pcg128_t r = pcg_setseq_128_xsl_rr_rr_128_random_r(rng);
+    if (r >= threshold)
+      return r % bound;
+  }
+}
+#endif
+
+//// Typedefs
+typedef struct pcg_state_setseq_64 pcg32_random_t;
+typedef struct pcg_state_64 pcg32s_random_t;
+typedef struct pcg_state_64 pcg32u_random_t;
+typedef struct pcg_state_64 pcg32f_random_t;
+//// random_r
+#define pcg32_random_r pcg_setseq_64_xsh_rr_32_random_r
+#define pcg32s_random_r pcg_oneseq_64_xsh_rr_32_random_r
+#define pcg32u_random_r pcg_unique_64_xsh_rr_32_random_r
+#define pcg32f_random_r pcg_mcg_64_xsh_rs_32_random_r
+//// boundedrand_r
+#define pcg32_boundedrand_r pcg_setseq_64_xsh_rr_32_boundedrand_r
+#define pcg32s_boundedrand_r pcg_oneseq_64_xsh_rr_32_boundedrand_r
+#define pcg32u_boundedrand_r pcg_unique_64_xsh_rr_32_boundedrand_r
+#define pcg32f_boundedrand_r pcg_mcg_64_xsh_rs_32_boundedrand_r
+//// srandom_r
+#define pcg32_srandom_r pcg_setseq_64_srandom_r
+#define pcg32s_srandom_r pcg_oneseq_64_srandom_r
+#define pcg32u_srandom_r pcg_unique_64_srandom_r
+#define pcg32f_srandom_r pcg_mcg_64_srandom_r
+//// advance_r
+#define pcg32_advance_r pcg_setseq_64_advance_r
+#define pcg32s_advance_r pcg_oneseq_64_advance_r
+#define pcg32u_advance_r pcg_unique_64_advance_r
+#define pcg32f_advance_r pcg_mcg_64_advance_r
+
+#if PCG_HAS_128BIT_OPS
+//// Typedefs
+typedef struct pcg_state_setseq_128 pcg64_random_t;
+typedef struct pcg_state_128 pcg64s_random_t;
+typedef struct pcg_state_128 pcg64u_random_t;
+typedef struct pcg_state_128 pcg64f_random_t;
+//// random_r
+#define pcg64_random_r pcg_setseq_128_xsl_rr_64_random_r
+#define pcg64s_random_r pcg_oneseq_128_xsl_rr_64_random_r
+#define pcg64u_random_r pcg_unique_128_xsl_rr_64_random_r
+#define pcg64f_random_r pcg_mcg_128_xsl_rr_64_random_r
+//// boundedrand_r
+#define pcg64_boundedrand_r pcg_setseq_128_xsl_rr_64_boundedrand_r
+#define pcg64s_boundedrand_r pcg_oneseq_128_xsl_rr_64_boundedrand_r
+#define pcg64u_boundedrand_r pcg_unique_128_xsl_rr_64_boundedrand_r
+#define pcg64f_boundedrand_r pcg_mcg_128_xsl_rr_64_boundedrand_r
+//// srandom_r
+#define pcg64_srandom_r pcg_setseq_128_srandom_r
+#define pcg64s_srandom_r pcg_oneseq_128_srandom_r
+#define pcg64u_srandom_r pcg_unique_128_srandom_r
+#define pcg64f_srandom_r pcg_mcg_128_srandom_r
+//// advance_r
+#define pcg64_advance_r pcg_setseq_128_advance_r
+#define pcg64s_advance_r pcg_oneseq_128_advance_r
+#define pcg64u_advance_r pcg_unique_128_advance_r
+#define pcg64f_advance_r pcg_mcg_128_advance_r
+#endif
+
+//// Typedefs
+typedef struct pcg_state_8 pcg8si_random_t;
+typedef struct pcg_state_16 pcg16si_random_t;
+typedef struct pcg_state_32 pcg32si_random_t;
+typedef struct pcg_state_64 pcg64si_random_t;
+//// random_r
+#define pcg8si_random_r pcg_oneseq_8_rxs_m_xs_8_random_r
+#define pcg16si_random_r pcg_oneseq_16_rxs_m_xs_16_random_r
+#define pcg32si_random_r pcg_oneseq_32_rxs_m_xs_32_random_r
+#define pcg64si_random_r pcg_oneseq_64_rxs_m_xs_64_random_r
+//// boundedrand_r
+#define pcg8si_boundedrand_r pcg_oneseq_8_rxs_m_xs_8_boundedrand_r
+#define pcg16si_boundedrand_r pcg_oneseq_16_rxs_m_xs_16_boundedrand_r
+#define pcg32si_boundedrand_r pcg_oneseq_32_rxs_m_xs_32_boundedrand_r
+#define pcg64si_boundedrand_r pcg_oneseq_64_rxs_m_xs_64_boundedrand_r
+//// srandom_r
+#define pcg8si_srandom_r pcg_oneseq_8_srandom_r
+#define pcg16si_srandom_r pcg_oneseq_16_srandom_r
+#define pcg32si_srandom_r pcg_oneseq_32_srandom_r
+#define pcg64si_srandom_r pcg_oneseq_64_srandom_r
+//// advance_r
+#define pcg8si_advance_r pcg_oneseq_8_advance_r
+#define pcg16si_advance_r pcg_oneseq_16_advance_r
+#define pcg32si_advance_r pcg_oneseq_32_advance_r
+#define pcg64si_advance_r pcg_oneseq_64_advance_r
+
+#if PCG_HAS_128BIT_OPS
+typedef struct pcg_state_128 pcg128si_random_t;
+#define pcg128si_random_r pcg_oneseq_128_rxs_m_xs_128_random_r
+#define pcg128si_boundedrand_r pcg_oneseq_128_rxs_m_xs_128_boundedrand_r
+#define pcg128si_srandom_r pcg_oneseq_128_srandom_r
+#define pcg128si_advance_r pcg_oneseq_128_advance_r
+#endif
+
+//// Typedefs
+typedef struct pcg_state_setseq_8 pcg8i_random_t;
+typedef struct pcg_state_setseq_16 pcg16i_random_t;
+typedef struct pcg_state_setseq_32 pcg32i_random_t;
+typedef struct pcg_state_setseq_64 pcg64i_random_t;
+//// random_r
+#define pcg8i_random_r pcg_setseq_8_rxs_m_xs_8_random_r
+#define pcg16i_random_r pcg_setseq_16_rxs_m_xs_16_random_r
+#define pcg32i_random_r pcg_setseq_32_rxs_m_xs_32_random_r
+#define pcg64i_random_r pcg_setseq_64_rxs_m_xs_64_random_r
+//// boundedrand_r
+#define pcg8i_boundedrand_r pcg_setseq_8_rxs_m_xs_8_boundedrand_r
+#define pcg16i_boundedrand_r pcg_setseq_16_rxs_m_xs_16_boundedrand_r
+#define pcg32i_boundedrand_r pcg_setseq_32_rxs_m_xs_32_boundedrand_r
+#define pcg64i_boundedrand_r pcg_setseq_64_rxs_m_xs_64_boundedrand_r
+//// srandom_r
+#define pcg8i_srandom_r pcg_setseq_8_srandom_r
+#define pcg16i_srandom_r pcg_setseq_16_srandom_r
+#define pcg32i_srandom_r pcg_setseq_32_srandom_r
+#define pcg64i_srandom_r pcg_setseq_64_srandom_r
+//// advance_r
+#define pcg8i_advance_r pcg_setseq_8_advance_r
+#define pcg16i_advance_r pcg_setseq_16_advance_r
+#define pcg32i_advance_r pcg_setseq_32_advance_r
+#define pcg64i_advance_r pcg_setseq_64_advance_r
+
+#if PCG_HAS_128BIT_OPS
+typedef struct pcg_state_setseq_128 pcg128i_random_t;
+#define pcg128i_random_r pcg_setseq_128_rxs_m_xs_128_random_r
+#define pcg128i_boundedrand_r pcg_setseq_128_rxs_m_xs_128_boundedrand_r
+#define pcg128i_srandom_r pcg_setseq_128_srandom_r
+#define pcg128i_advance_r pcg_setseq_128_advance_r
+#endif
+
+extern uint32_t pcg32_random();
+extern uint32_t pcg32_boundedrand(uint32_t bound);
+extern void pcg32_srandom(uint64_t seed, uint64_t seq);
+extern void pcg32_advance(uint64_t delta);
+
+#if PCG_HAS_128BIT_OPS
+extern uint64_t pcg64_random();
+extern uint64_t pcg64_boundedrand(uint64_t bound);
+extern void pcg64_srandom(pcg128_t seed, pcg128_t seq);
+extern void pcg64_advance(pcg128_t delta);
+#endif
+
+/*
+ * Static initialization constants (if you can't call srandom for some
+ * bizarre reason).
+ */
+
+#define PCG32_INITIALIZER PCG_STATE_SETSEQ_64_INITIALIZER
+#define PCG32U_INITIALIZER PCG_STATE_UNIQUE_64_INITIALIZER
+#define PCG32S_INITIALIZER PCG_STATE_ONESEQ_64_INITIALIZER
+#define PCG32F_INITIALIZER PCG_STATE_MCG_64_INITIALIZER
+
+#if PCG_HAS_128BIT_OPS
+#define PCG64_INITIALIZER PCG_STATE_SETSEQ_128_INITIALIZER
+#define PCG64U_INITIALIZER PCG_STATE_UNIQUE_128_INITIALIZER
+#define PCG64S_INITIALIZER PCG_STATE_ONESEQ_128_INITIALIZER
+#define PCG64F_INITIALIZER PCG_STATE_MCG_128_INITIALIZER
+#endif
+
+#define PCG8SI_INITIALIZER PCG_STATE_ONESEQ_8_INITIALIZER
+#define PCG16SI_INITIALIZER PCG_STATE_ONESEQ_16_INITIALIZER
+#define PCG32SI_INITIALIZER PCG_STATE_ONESEQ_32_INITIALIZER
+#define PCG64SI_INITIALIZER PCG_STATE_ONESEQ_64_INITIALIZER
+#if PCG_HAS_128BIT_OPS
+#define PCG128SI_INITIALIZER PCG_STATE_ONESEQ_128_INITIALIZER
+#endif
+
+#define PCG8I_INITIALIZER PCG_STATE_SETSEQ_8_INITIALIZER
+#define PCG16I_INITIALIZER PCG_STATE_SETSEQ_16_INITIALIZER
+#define PCG32I_INITIALIZER PCG_STATE_SETSEQ_32_INITIALIZER
+#define PCG64I_INITIALIZER PCG_STATE_SETSEQ_64_INITIALIZER
+#if PCG_HAS_128BIT_OPS
+#define PCG128I_INITIALIZER PCG_STATE_SETSEQ_128_INITIALIZER
+#endif
+
+#if __cplusplus
+}
+#endif
+
+#endif // PCG_VARIANTS_H_INCLUDED
diff --git a/numpy/random/src/philox/LICENSE.md b/numpy/random/src/philox/LICENSE.md
new file mode 100644
index 000000000..4a9f6bb29
--- /dev/null
+++ b/numpy/random/src/philox/LICENSE.md
@@ -0,0 +1,31 @@
+# THREEFRY
+
+Copyright 2010-2012, D. E. Shaw Research.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions, and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions, and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of D. E. Shaw Research nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/numpy/random/src/philox/philox-benchmark.c b/numpy/random/src/philox/philox-benchmark.c
new file mode 100644
index 000000000..0cab04cf5
--- /dev/null
+++ b/numpy/random/src/philox/philox-benchmark.c
@@ -0,0 +1,38 @@
+/*
+ * Simple benchamrk command
+ *
+ *  cl philox-benchmark.c /Ox
+ *
+ *  gcc philox-benchmark.c -O3 -o philox-benchmark
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ */
+#include "Random123/philox.h"
+#include <inttypes.h>
+#include <stdio.h>
+#include <time.h>
+
+#define N 1000000000
+
+int main() {
+  philox4x64_ctr_t ctr = {{0, 0, 0, 0}};
+  philox4x64_key_t key = {{0, 0xDEADBEAF}};
+  philox4x64_ctr_t out;
+  uint64_t count = 0, sum = 0;
+  int i, j;
+  clock_t begin = clock();
+  for (i = 0; i < N / 4UL; i++) {
+    ctr.v[0]++;
+    out = philox4x64_R(philox4x64_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      sum += out.v[j];
+      count++;
+    }
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(N / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/philox/philox-test-data-gen.c b/numpy/random/src/philox/philox-test-data-gen.c
new file mode 100644
index 000000000..442e18b55
--- /dev/null
+++ b/numpy/random/src/philox/philox-test-data-gen.c
@@ -0,0 +1,82 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl philox-test-data-gen.c /Ox
+ *  philox-test-data-gen.exe
+ *
+ *  gcc philox-test-data-gen.c -o philox-test-data-gen
+ *  ./philox-test-data-gen
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "Random123/philox.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  philox4x64_ctr_t ctr = {{0, 0, 0, 0}};
+  philox4x64_key_t key = {{0, 0}};
+  uint64_t state, seed = 0xDEADBEAF;
+  philox4x64_ctr_t out;
+  uint64_t store[N];
+  state = seed;
+  int i, j;
+  for (i = 0; i < 2; i++) {
+    key.v[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N / 4UL; i++) {
+    ctr.v[0]++;
+    out = philox4x64_R(philox4x64_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      store[i * 4 + j] = out.v[j];
+    }
+  }
+
+  FILE *fp;
+  fp = fopen("philox-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  ctr.v[0] = 0;
+  state = seed = 0;
+  for (i = 0; i < 2; i++) {
+    key.v[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N / 4UL; i++) {
+    ctr.v[0]++;
+    out = philox4x64_R(philox4x64_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      store[i * 4 + j] = out.v[j];
+    }
+  }
+
+  fp = fopen("philox-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/philox/philox.c b/numpy/random/src/philox/philox.c
new file mode 100644
index 000000000..3382c60d6
--- /dev/null
+++ b/numpy/random/src/philox/philox.c
@@ -0,0 +1,29 @@
+#include "philox.h"
+
+extern INLINE uint64_t philox_next64(philox_state *state);
+
+extern INLINE uint32_t philox_next32(philox_state *state);
+
+extern void philox_jump(philox_state *state) {
+  /* Advances state as-if 2^128 draws were made */
+  state->ctr->v[2]++;
+  if (state->ctr->v[2] == 0) {
+    state->ctr->v[3]++;
+  }
+}
+
+extern void philox_advance(uint64_t *step, philox_state *state) {
+  int i, carry = 0;
+  uint64_t v_orig;
+  for (i = 0; i < 4; i++) {
+    if (carry == 1) {
+      state->ctr->v[i]++;
+      carry = state->ctr->v[i] == 0 ? 1 : 0;
+    }
+    v_orig = state->ctr->v[i];
+    state->ctr->v[i] += step[i];
+    if (state->ctr->v[i] < v_orig && carry == 0) {
+      carry = 1;
+    }
+  }
+}
diff --git a/numpy/random/src/philox/philox.h b/numpy/random/src/philox/philox.h
new file mode 100644
index 000000000..411404b55
--- /dev/null
+++ b/numpy/random/src/philox/philox.h
@@ -0,0 +1,253 @@
+#ifndef _RANDOMDGEN__PHILOX_H_
+#define _RANDOMDGEN__PHILOX_H_
+
+#include <inttypes.h>
+
+#ifdef _WIN32
+#define INLINE __inline __forceinline
+#else
+#define INLINE inline
+#endif
+
+#define PHILOX_BUFFER_SIZE 4L
+
+struct r123array2x64 {
+  uint64_t v[2];
+};
+struct r123array4x64 {
+  uint64_t v[4];
+};
+
+enum r123_enum_philox4x64 { philox4x64_rounds = 10 };
+typedef struct r123array4x64 philox4x64_ctr_t;
+typedef struct r123array2x64 philox4x64_key_t;
+typedef struct r123array2x64 philox4x64_ukey_t;
+
+static INLINE struct r123array2x64
+_philox4x64bumpkey(struct r123array2x64 key) {
+  key.v[0] += (0x9E3779B97F4A7C15ULL);
+  key.v[1] += (0xBB67AE8584CAA73BULL);
+  return key;
+}
+
+#ifdef _WIN32
+#include <intrin.h>
+/* TODO: This isn't correct for many platforms */
+#ifdef _WIN64
+#pragma intrinsic(_umul128)
+#else
+#pragma intrinsic(__emulu)
+static INLINE uint64_t _umul128(uint64_t a, uint64_t b, uint64_t *high) {
+
+  uint64_t a_lo, a_hi, b_lo, b_hi, a_x_b_hi, a_x_b_mid, a_x_b_lo, b_x_a_mid,
+      carry_bit;
+  a_lo = (uint32_t)a;
+  a_hi = a >> 32;
+  b_lo = (uint32_t)b;
+  b_hi = b >> 32;
+
+  a_x_b_hi = __emulu(a_hi, b_hi);
+  a_x_b_mid = __emulu(a_hi, b_lo);
+  b_x_a_mid = __emulu(b_hi, a_lo);
+  a_x_b_lo = __emulu(a_lo, b_lo);
+
+  carry_bit = ((uint64_t)(uint32_t)a_x_b_mid + (uint64_t)(uint32_t)b_x_a_mid +
+               (a_x_b_lo >> 32)) >>
+              32;
+
+  *high = a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
+
+  return a_x_b_lo + ((a_x_b_mid + b_x_a_mid) << 32);
+}
+#endif
+static INLINE uint64_t mulhilo64(uint64_t a, uint64_t b, uint64_t *hip) {
+  return _umul128(a, b, hip);
+}
+#else
+#if __SIZEOF_INT128__
+static INLINE uint64_t mulhilo64(uint64_t a, uint64_t b, uint64_t *hip) {
+  __uint128_t product = ((__uint128_t)a) * ((__uint128_t)b);
+  *hip = product >> 64;
+  return (uint64_t)product;
+}
+#else
+static INLINE uint64_t _umul128(uint64_t a, uint64_t b, uint64_t *high) {
+
+  uint64_t a_lo, a_hi, b_lo, b_hi, a_x_b_hi, a_x_b_mid, a_x_b_lo, b_x_a_mid,
+      carry_bit;
+  a_lo = (uint32_t)a;
+  a_hi = a >> 32;
+  b_lo = (uint32_t)b;
+  b_hi = b >> 32;
+
+  a_x_b_hi = a_hi * b_hi;
+  a_x_b_mid = a_hi * b_lo;
+  b_x_a_mid = b_hi * a_lo;
+  a_x_b_lo = a_lo * b_lo;
+
+  carry_bit = ((uint64_t)(uint32_t)a_x_b_mid + (uint64_t)(uint32_t)b_x_a_mid +
+               (a_x_b_lo >> 32)) >>
+              32;
+
+  *high = a_x_b_hi + (a_x_b_mid >> 32) + (b_x_a_mid >> 32) + carry_bit;
+
+  return a_x_b_lo + ((a_x_b_mid + b_x_a_mid) << 32);
+}
+static INLINE uint64_t mulhilo64(uint64_t a, uint64_t b, uint64_t *hip) {
+  return _umul128(a, b, hip);
+}
+#endif
+#endif
+
+static INLINE struct r123array4x64 _philox4x64round(struct r123array4x64 ctr,
+                                                    struct r123array2x64 key);
+
+static INLINE struct r123array4x64 _philox4x64round(struct r123array4x64 ctr,
+                                                    struct r123array2x64 key) {
+  uint64_t hi0;
+  uint64_t hi1;
+  uint64_t lo0 = mulhilo64((0xD2E7470EE14C6C93ULL), ctr.v[0], &hi0);
+  uint64_t lo1 = mulhilo64((0xCA5A826395121157ULL), ctr.v[2], &hi1);
+  struct r123array4x64 out = {
+      {hi1 ^ ctr.v[1] ^ key.v[0], lo1, hi0 ^ ctr.v[3] ^ key.v[1], lo0}};
+  return out;
+}
+
+static INLINE philox4x64_key_t philox4x64keyinit(philox4x64_ukey_t uk) {
+  return uk;
+}
+static INLINE philox4x64_ctr_t philox4x64_R(unsigned int R,
+                                            philox4x64_ctr_t ctr,
+                                            philox4x64_key_t key);
+
+static INLINE philox4x64_ctr_t philox4x64_R(unsigned int R,
+                                            philox4x64_ctr_t ctr,
+                                            philox4x64_key_t key) {
+  if (R > 0) {
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 1) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 2) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 3) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 4) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 5) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 6) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 7) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 8) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 9) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 10) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 11) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 12) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 13) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 14) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  if (R > 15) {
+    key = _philox4x64bumpkey(key);
+    ctr = _philox4x64round(ctr, key);
+  }
+  return ctr;
+}
+
+typedef struct s_philox_state {
+  philox4x64_ctr_t *ctr;
+  philox4x64_key_t *key;
+  int buffer_pos;
+  uint64_t buffer[PHILOX_BUFFER_SIZE];
+  int has_uint32;
+  uint32_t uinteger;
+} philox_state;
+
+static INLINE uint64_t philox_next(philox_state *state) {
+  uint64_t out;
+  int i;
+  philox4x64_ctr_t ct;
+
+  if (state->buffer_pos < PHILOX_BUFFER_SIZE) {
+    out = state->buffer[state->buffer_pos];
+    state->buffer_pos++;
+    return out;
+  }
+  /* generate 4 new uint64_t */
+  state->ctr->v[0]++;
+  /* Handle carry */
+  if (state->ctr->v[0] == 0) {
+    state->ctr->v[1]++;
+    if (state->ctr->v[1] == 0) {
+      state->ctr->v[2]++;
+      if (state->ctr->v[2] == 0) {
+        state->ctr->v[3]++;
+      }
+    }
+  }
+  ct = philox4x64_R(philox4x64_rounds, *state->ctr, *state->key);
+  for (i = 0; i < 4; i++) {
+    state->buffer[i] = ct.v[i];
+  }
+  state->buffer_pos = 1;
+  return state->buffer[0];
+}
+
+static INLINE uint64_t philox_next64(philox_state *state) {
+  return philox_next(state);
+}
+
+static INLINE uint32_t philox_next32(philox_state *state) {
+  uint64_t next;
+
+  if (state->has_uint32) {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = philox_next(state);
+
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
+
+extern void philox_jump(philox_state *state);
+
+extern void philox_advance(uint64_t *step, philox_state *state);
+
+#endif
diff --git a/numpy/random/src/splitmix64/LICENSE.md b/numpy/random/src/splitmix64/LICENSE.md
new file mode 100644
index 000000000..3c4d73b92
--- /dev/null
+++ b/numpy/random/src/splitmix64/LICENSE.md
@@ -0,0 +1,9 @@
+# SPLITMIX64
+
+Written in 2015 by Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>.
\ No newline at end of file
diff --git a/numpy/random/src/splitmix64/splitmix64.c b/numpy/random/src/splitmix64/splitmix64.c
new file mode 100644
index 000000000..79a845982
--- /dev/null
+++ b/numpy/random/src/splitmix64/splitmix64.c
@@ -0,0 +1,29 @@
+/*  Written in 2015 by Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>.
+
+Modified 2018 by Kevin Sheppard.  Modifications licensed under the NCSA
+license.
+*/
+
+/* This is a fixed-increment version of Java 8's SplittableRandom generator
+   See http://dx.doi.org/10.1145/2714064.2660195 and
+   http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html
+
+   It is a very fast generator passing BigCrush, and it can be useful if
+   for some reason you absolutely want 64 bits of state; otherwise, we
+   rather suggest to use a xoroshiro128+ (for moderately parallel
+   computations) or xorshift1024* (for massively parallel computations)
+   generator. */
+
+#include "splitmix64.h"
+
+extern inline uint64_t splitmix64_next(uint64_t *state);
+
+extern inline uint64_t splitmix64_next64(splitmix64_state *state);
+
+extern inline uint32_t splitmix64_next32(splitmix64_state *state);
diff --git a/numpy/random/src/splitmix64/splitmix64.h b/numpy/random/src/splitmix64/splitmix64.h
new file mode 100644
index 000000000..880132970
--- /dev/null
+++ b/numpy/random/src/splitmix64/splitmix64.h
@@ -0,0 +1,39 @@
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define inline __forceinline
+#else
+#include <inttypes.h>
+#endif
+#else
+#include <inttypes.h>
+#endif
+
+typedef struct s_splitmix64_state {
+  uint64_t state;
+  int has_uint32;
+  uint32_t uinteger;
+} splitmix64_state;
+
+static inline uint64_t splitmix64_next(uint64_t *state) {
+  uint64_t z = (state[0] += 0x9e3779b97f4a7c15);
+  z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+  z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+  return z ^ (z >> 31);
+}
+
+static inline uint64_t splitmix64_next64(splitmix64_state *state) {
+  return splitmix64_next(&state->state);
+}
+
+static inline uint32_t splitmix64_next32(splitmix64_state *state) {
+  uint64_t next;
+  if (state->has_uint32) {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = splitmix64_next64(state);
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
diff --git a/numpy/random/src/splitmix64/splitmix64.orig.c b/numpy/random/src/splitmix64/splitmix64.orig.c
new file mode 100644
index 000000000..df6133aab
--- /dev/null
+++ b/numpy/random/src/splitmix64/splitmix64.orig.c
@@ -0,0 +1,28 @@
+/*  Written in 2015 by Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is a fixed-increment version of Java 8's SplittableRandom generator
+   See http://dx.doi.org/10.1145/2714064.2660195 and
+   http://docs.oracle.com/javase/8/docs/api/java/util/SplittableRandom.html
+
+   It is a very fast generator passing BigCrush, and it can be useful if
+   for some reason you absolutely want 64 bits of state; otherwise, we
+   rather suggest to use a xoroshiro128+ (for moderately parallel
+   computations) or xorshift1024* (for massively parallel computations)
+   generator. */
+
+uint64_t x; /* The state can be seeded with any value. */
+
+uint64_t next() {
+  uint64_t z = (x += 0x9e3779b97f4a7c15);
+  z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
+  z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
+  return z ^ (z >> 31);
+}
diff --git a/numpy/random/src/threefry/LICENSE.md b/numpy/random/src/threefry/LICENSE.md
new file mode 100644
index 000000000..4a9f6bb29
--- /dev/null
+++ b/numpy/random/src/threefry/LICENSE.md
@@ -0,0 +1,31 @@
+# THREEFRY
+
+Copyright 2010-2012, D. E. Shaw Research.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions, and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions, and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of D. E. Shaw Research nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/numpy/random/src/threefry/threefry-benchmark.c b/numpy/random/src/threefry/threefry-benchmark.c
new file mode 100644
index 000000000..6d6239cd3
--- /dev/null
+++ b/numpy/random/src/threefry/threefry-benchmark.c
@@ -0,0 +1,38 @@
+/*
+ * Simple benchamrk command
+ *
+ *  cl threefry-benchmark.c /Ox
+ *
+ *  gcc threefry-benchmark.c -O3 -o threefry-benchmark
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ */
+#include "Random123/threefry.h"
+#include <inttypes.h>
+#include <stdio.h>
+#include <time.h>
+
+#define N 1000000000
+
+int main() {
+  threefry4x64_key_t ctr = {{0, 0, 0, 0}};
+  threefry4x64_ctr_t key = {{0xDEADBEAF, 0, 0, 0}};
+  threefry4x64_ctr_t out;
+  uint64_t count = 0, sum = 0;
+  int i, j;
+  clock_t begin = clock();
+  for (i = 0; i < N / 4UL; i++) {
+    ctr.v[0]++;
+    out = threefry4x64_R(threefry4x64_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      sum += out.v[j];
+      count++;
+    }
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(N / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/threefry/threefry-orig.c b/numpy/random/src/threefry/threefry-orig.c
new file mode 100644
index 000000000..d27cfd797
--- /dev/null
+++ b/numpy/random/src/threefry/threefry-orig.c
@@ -0,0 +1,83 @@
+/*
+Copyright (c) 2017, Pierre de Buyl
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "threefry.h"
+#include <stdint.h>
+
+#define N_WORDS 2
+#define KEY_LENGTH 3
+#define C240 0x1BD11BDAA9FC1A22
+#define N_ROUNDS 20
+#define MASK 0xffffffffffffffff
+#define DOUBLE_MULT 5.421010862427522e-20
+
+static const int ROTATION[] = {16, 42, 12, 31, 16, 32, 24, 21};
+
+uint64_t rotl_64(uint64_t x, int d) { return ((x << d) | (x >> (64 - d))); }
+
+threefry_t mix(threefry_t x, int R) {
+  x.c0 += x.c1;
+  x.c1 = rotl_64(x.c1, R) ^ x.c0;
+  return x;
+}
+
+threefry_t threefry(threefry_t p, threefry_t k) {
+  uint64_t K[] = {k.c0, k.c1, C240 ^ k.c0 ^ k.c1};
+  int rmod4, rdiv4;
+  threefry_t x;
+  x = p;
+  for (int r = 0; r < N_ROUNDS; r++) {
+    rmod4 = r % 4;
+    if (rmod4 == 0) {
+      rdiv4 = r / 4;
+      x.c0 += K[rdiv4 % KEY_LENGTH];
+      x.c1 += K[(rdiv4 + 1) % KEY_LENGTH] + rdiv4;
+    }
+    x = mix(x, ROTATION[r % 8]);
+  }
+  x.c0 += K[(N_ROUNDS / 4) % KEY_LENGTH];
+  x.c1 += K[(N_ROUNDS / 4 + 1) % KEY_LENGTH] + N_ROUNDS / 4;
+  return x;
+}
+
+uint64_t threefry_uint64(threefry_t *c, threefry_t *k) {
+  threefry_t x;
+  x = threefry(*c, *k);
+  c->c0++;
+  return x.c0;
+}
+
+double threefry_double(threefry_t *c, threefry_t *k) {
+  threefry_t x;
+  x = threefry(*c, *k);
+  c->c0++;
+  return x.c0 * DOUBLE_MULT;
+}
diff --git a/numpy/random/src/threefry/threefry-test-data-gen.c b/numpy/random/src/threefry/threefry-test-data-gen.c
new file mode 100644
index 000000000..328eb2575
--- /dev/null
+++ b/numpy/random/src/threefry/threefry-test-data-gen.c
@@ -0,0 +1,83 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl threefry-test-data-gen.c /Ox ../splitmix64/splitmix64.c /Ox
+ *  threefry-test-data-gen.exe
+ *
+ *  gcc threefry-test-data-gen.c ../splitmix64/splitmix64.c /Ox -o
+ * threefry-test-data-gen
+ *  ./threefry-test-data-gen
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "Random123/threefry.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  threefry4x64_key_t ctr = {{0, 0, 0, 0}};
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  threefry4x64_ctr_t key = {{0}};
+  threefry4x64_ctr_t out;
+  uint64_t store[N];
+  int i, j;
+  for (i = 0; i < 4; i++) {
+    key.v[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N / 4UL; i++) {
+    ctr.v[0]++;
+    out = threefry4x64_R(threefry4x64_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      store[i * 4 + j] = out.v[j];
+    }
+  }
+
+  FILE *fp;
+  fp = fopen("threefry-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  ctr.v[0] = 0;
+  state = seed = 0;
+  for (i = 0; i < 4; i++) {
+    key.v[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N / 4; i++) {
+    ctr.v[0]++;
+    out = threefry4x64_R(threefry4x64_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      store[i * 4 + j] = out.v[j];
+    }
+  }
+
+  fp = fopen("threefry-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/threefry/threefry.c b/numpy/random/src/threefry/threefry.c
new file mode 100644
index 000000000..19c37df1b
--- /dev/null
+++ b/numpy/random/src/threefry/threefry.c
@@ -0,0 +1,29 @@
+#include "threefry.h"
+
+extern INLINE uint64_t threefry_next64(threefry_state *state);
+
+extern INLINE uint32_t threefry_next32(threefry_state *state);
+
+extern void threefry_jump(threefry_state *state) {
+  /* Advances state as-if 2^128 draws were made */
+  state->ctr->v[2]++;
+  if (state->ctr->v[2] == 0) {
+    state->ctr->v[3]++;
+  }
+}
+
+extern void threefry_advance(uint64_t *step, threefry_state *state) {
+  int i, carry = 0;
+  uint64_t v_orig;
+  for (i = 0; i < 4; i++) {
+    if (carry == 1) {
+      state->ctr->v[i]++;
+      carry = state->ctr->v[i] == 0 ? 1 : 0;
+    }
+    v_orig = state->ctr->v[i];
+    state->ctr->v[i] += step[i];
+    if (state->ctr->v[i] < v_orig && carry == 0) {
+      carry = 1;
+    }
+  }
+}
diff --git a/numpy/random/src/threefry/threefry.h b/numpy/random/src/threefry/threefry.h
new file mode 100644
index 000000000..297c1241a
--- /dev/null
+++ b/numpy/random/src/threefry/threefry.h
@@ -0,0 +1,341 @@
+/*
+Adapted from random123's threefry.h
+*/
+#ifndef _RANDOMDGEN__THREEFRY_H_
+#define _RANDOMDGEN__THREEFRY_H_
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define INLINE __forceinline
+#else
+#include <inttypes.h>
+#define INLINE __inline __forceinline
+#endif
+#else
+#include <inttypes.h>
+#define INLINE inline
+#endif
+
+#define THREEFRY_BUFFER_SIZE 4L
+
+enum r123_enum_threefry64x4 {
+  /* These are the R_256 constants from the Threefish reference sources
+     with names changed to R_64x4... */
+  R_64x4_0_0 = 14,
+  R_64x4_0_1 = 16,
+  R_64x4_1_0 = 52,
+  R_64x4_1_1 = 57,
+  R_64x4_2_0 = 23,
+  R_64x4_2_1 = 40,
+  R_64x4_3_0 = 5,
+  R_64x4_3_1 = 37,
+  R_64x4_4_0 = 25,
+  R_64x4_4_1 = 33,
+  R_64x4_5_0 = 46,
+  R_64x4_5_1 = 12,
+  R_64x4_6_0 = 58,
+  R_64x4_6_1 = 22,
+  R_64x4_7_0 = 32,
+  R_64x4_7_1 = 32
+};
+
+struct r123array4x64 {
+  uint64_t v[4];
+}; /* r123array4x64 */
+
+typedef struct r123array4x64 threefry4x64_key_t;
+typedef struct r123array4x64 threefry4x64_ctr_t;
+
+static INLINE uint64_t RotL_64(uint64_t x, unsigned int N);
+static INLINE uint64_t RotL_64(uint64_t x, unsigned int N) {
+  return (x << (N & 63)) | (x >> ((64 - N) & 63));
+}
+
+static INLINE threefry4x64_ctr_t threefry4x64_R(unsigned int Nrounds,
+                                                threefry4x64_ctr_t in,
+                                                threefry4x64_key_t k);
+static INLINE threefry4x64_ctr_t threefry4x64_R(unsigned int Nrounds,
+                                                threefry4x64_ctr_t in,
+                                                threefry4x64_key_t k) {
+  threefry4x64_ctr_t X;
+  uint64_t ks[4 + 1];
+  int i;
+  ks[4] = ((0xA9FC1A22) + (((uint64_t)(0x1BD11BDA)) << 32));
+  for (i = 0; i < 4; i++) {
+    ks[i] = k.v[i];
+    X.v[i] = in.v[i];
+    ks[4] ^= k.v[i];
+  }
+  X.v[0] += ks[0];
+  X.v[1] += ks[1];
+  X.v[2] += ks[2];
+  X.v[3] += ks[3];
+  if (Nrounds > 0) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 1) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 2) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 3) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 3) {
+    X.v[0] += ks[1];
+    X.v[1] += ks[2];
+    X.v[2] += ks[3];
+    X.v[3] += ks[4];
+    X.v[4 - 1] += 1;
+  }
+  if (Nrounds > 4) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 5) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 6) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 7) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 7) {
+    X.v[0] += ks[2];
+    X.v[1] += ks[3];
+    X.v[2] += ks[4];
+    X.v[3] += ks[0];
+    X.v[4 - 1] += 2;
+  }
+  if (Nrounds > 8) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 9) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 10) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 11) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 11) {
+    X.v[0] += ks[3];
+    X.v[1] += ks[4];
+    X.v[2] += ks[0];
+    X.v[3] += ks[1];
+    X.v[4 - 1] += 3;
+  }
+  if (Nrounds > 12) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 13) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 14) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 15) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 15) {
+    X.v[0] += ks[4];
+    X.v[1] += ks[0];
+    X.v[2] += ks[1];
+    X.v[3] += ks[2];
+    X.v[4 - 1] += 4;
+  }
+  if (Nrounds > 16) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 17) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 18) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 19) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 19) {
+    X.v[0] += ks[0];
+    X.v[1] += ks[1];
+    X.v[2] += ks[2];
+    X.v[3] += ks[3];
+    X.v[4 - 1] += 5;
+  }
+  /* Maximum of 20 rounds */
+  if (Nrounds > 20) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_64(X.v[1], R_64x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_64(X.v[3], R_64x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  return X;
+}
+enum r123_enum_threefry4x64 { threefry4x64_rounds = 20 };
+
+typedef struct s_threefry_state {
+  threefry4x64_key_t *ctr;
+  threefry4x64_ctr_t *key;
+  int buffer_pos;
+  uint64_t buffer[THREEFRY_BUFFER_SIZE];
+  int has_uint32;
+  uint32_t uinteger;
+} threefry_state;
+
+static INLINE uint64_t threefry_next(threefry_state *state) {
+  int i;
+  threefry4x64_ctr_t ct;
+  uint64_t out;
+  if (state->buffer_pos < THREEFRY_BUFFER_SIZE) {
+    out = state->buffer[state->buffer_pos];
+    state->buffer_pos++;
+    return out;
+  }
+  /* generate 4 new uint64_t */
+  state->ctr->v[0]++;
+  /* Handle carry */
+  if (state->ctr->v[0] == 0) {
+    state->ctr->v[1]++;
+    if (state->ctr->v[1] == 0) {
+      state->ctr->v[2]++;
+      if (state->ctr->v[2] == 0) {
+        state->ctr->v[3]++;
+      }
+    }
+  }
+  ct = threefry4x64_R(threefry4x64_rounds, *state->ctr, *state->key);
+  for (i = 0; i < 4; i++) {
+    state->buffer[i] = ct.v[i];
+  }
+  state->buffer_pos = 1;
+  return state->buffer[0];
+}
+
+static INLINE uint64_t threefry_next64(threefry_state *state) {
+  return threefry_next(state);
+}
+
+static INLINE uint32_t threefry_next32(threefry_state *state) {
+  uint64_t next;
+  if (state->has_uint32) {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = threefry_next(state);
+
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
+
+extern void threefry_jump(threefry_state *state);
+
+extern void threefry_advance(uint64_t *step, threefry_state *state);
+
+#endif
diff --git a/numpy/random/src/threefry32/LICENSE.md b/numpy/random/src/threefry32/LICENSE.md
new file mode 100644
index 000000000..591cd75f4
--- /dev/null
+++ b/numpy/random/src/threefry32/LICENSE.md
@@ -0,0 +1,31 @@
+# THREEFRY32
+
+Copyright 2010-2012, D. E. Shaw Research.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions, and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions, and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of D. E. Shaw Research nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/numpy/random/src/threefry32/threefry32-test-data-gen.c b/numpy/random/src/threefry32/threefry32-test-data-gen.c
new file mode 100644
index 000000000..0e6229995
--- /dev/null
+++ b/numpy/random/src/threefry32/threefry32-test-data-gen.c
@@ -0,0 +1,88 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl threefry32-test-data-gen.c /Ox ../splitmix64/splitmix64.c /Ox
+ *  threefry32-test-data-gen.exe
+ *
+ *  gcc threefry32-test-data-gen.c ../splitmix64/splitmix64.c /Ox -o
+ * threefry32-test-data-gen
+ *  ./threefry32-test-data-gen
+ *
+ * Requires the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "Random123/threefry.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  threefry4x32_key_t ctr = {{0, 0, 0, 0}};
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  threefry4x32_ctr_t key = {{0}};
+  threefry4x32_ctr_t out;
+  uint64_t store[N];
+  uint64_t seed_val;
+  int i, j;
+  for (i = 0; i < 4; i++) {
+    seed_val = splitmix64_next(&state);
+    key.v[2*i] = (uint32_t)seed_val;
+    key.v[2*i+1] = (uint32_t)(seed_val >> 32);
+  }
+  for (i = 0; i < N / 4UL; i++) {
+    ctr.v[0]++;
+    out = threefry4x32_R(threefry4x32_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      store[i * 4 + j] = out.v[j];
+    }
+  }
+
+  FILE *fp;
+  fp = fopen("threefry32-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  ctr.v[0] = 0;
+  state = seed = 0;
+  for (i = 0; i < 4; i++) {
+    seed_val = splitmix64_next(&state);
+    key.v[2*i] = (uint32_t)seed_val;
+    key.v[2*i+1] = (uint32_t)(seed_val >> 32);
+  }
+  for (i = 0; i < N / 4; i++) {
+    ctr.v[0]++;
+    out = threefry4x32_R(threefry4x32_rounds, ctr, key);
+    for (j = 0; j < 4; j++) {
+      store[i * 4 + j] = out.v[j];
+    }
+  }
+
+  fp = fopen("threefry32-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/threefry32/threefry32.c b/numpy/random/src/threefry32/threefry32.c
new file mode 100644
index 000000000..500e9482d
--- /dev/null
+++ b/numpy/random/src/threefry32/threefry32.c
@@ -0,0 +1,29 @@
+#include "threefry32.h"
+
+extern INLINE uint64_t threefry32_next64(threefry32_state *state);
+
+extern INLINE uint32_t threefry32_next32(threefry32_state *state);
+
+extern void threefry32_jump(threefry32_state *state) {
+  /* Advances state as-if 2^64 draws were made */
+  state->ctr->v[2]++;
+  if (state->ctr->v[2] == 0) {
+    state->ctr->v[3]++;
+  }
+}
+
+extern void threefry32_advance(uint32_t *step, threefry32_state *state) {
+  int i, carry = 0;
+  uint32_t v_orig;
+  for (i = 0; i < 4; i++) {
+    if (carry == 1) {
+      state->ctr->v[i]++;
+      carry = state->ctr->v[i] == 0 ? 1 : 0;
+    }
+    v_orig = state->ctr->v[i];
+    state->ctr->v[i] += step[i];
+    if (state->ctr->v[i] < v_orig && carry == 0) {
+      carry = 1;
+    }
+  }
+}
diff --git a/numpy/random/src/threefry32/threefry32.h b/numpy/random/src/threefry32/threefry32.h
new file mode 100644
index 000000000..74a85c42b
--- /dev/null
+++ b/numpy/random/src/threefry32/threefry32.h
@@ -0,0 +1,842 @@
+/*
+Adapted from random123's threefry.h
+*/
+#ifndef _RANDOMDGEN__THREEFRY32_H_
+#define _RANDOMDGEN__THREEFRY32_H_
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define INLINE __forceinline
+#else
+#include <inttypes.h>
+#define INLINE __inline __forceinline
+#endif
+#else
+#include <inttypes.h>
+#define INLINE inline
+#endif
+
+#define THREEFRY_BUFFER_SIZE 4L
+
+static INLINE uint32_t RotL_32(uint32_t x, unsigned int N);
+static INLINE uint32_t RotL_32(uint32_t x, unsigned int N) {
+  return (x << (N & 31)) | (x >> ((32 - N) & 31));
+}
+
+struct r123array4x32 {
+  uint32_t v[4];
+};
+
+enum r123_enum_threefry32x4 {
+
+  R_32x4_0_0 = 10,
+  R_32x4_0_1 = 26,
+  R_32x4_1_0 = 11,
+  R_32x4_1_1 = 21,
+  R_32x4_2_0 = 13,
+  R_32x4_2_1 = 27,
+  R_32x4_3_0 = 23,
+  R_32x4_3_1 = 5,
+  R_32x4_4_0 = 6,
+  R_32x4_4_1 = 20,
+  R_32x4_5_0 = 17,
+  R_32x4_5_1 = 11,
+  R_32x4_6_0 = 25,
+  R_32x4_6_1 = 10,
+  R_32x4_7_0 = 18,
+  R_32x4_7_1 = 20
+
+};
+
+typedef struct r123array4x32 threefry4x32_ctr_t;
+typedef struct r123array4x32 threefry4x32_key_t;
+typedef struct r123array4x32 threefry4x32_ukey_t;
+static INLINE threefry4x32_key_t threefry4x32keyinit(threefry4x32_ukey_t uk) {
+  return uk;
+};
+static INLINE threefry4x32_ctr_t threefry4x32_R(unsigned int Nrounds,
+                                                threefry4x32_ctr_t in,
+                                                threefry4x32_key_t k);
+static INLINE threefry4x32_ctr_t threefry4x32_R(unsigned int Nrounds,
+                                                threefry4x32_ctr_t in,
+                                                threefry4x32_key_t k) {
+  threefry4x32_ctr_t X;
+  uint32_t ks[4 + 1];
+  int i;
+  ks[4] = 0x1BD11BDA;
+  for (i = 0; i < 4; i++) {
+    ks[i] = k.v[i];
+    X.v[i] = in.v[i];
+    ks[4] ^= k.v[i];
+  }
+  X.v[0] += ks[0];
+  X.v[1] += ks[1];
+  X.v[2] += ks[2];
+  X.v[3] += ks[3];
+  if (Nrounds > 0) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 1) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 2) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 3) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 3) {
+    X.v[0] += ks[1];
+    X.v[1] += ks[2];
+    X.v[2] += ks[3];
+    X.v[3] += ks[4];
+    X.v[4 - 1] += 1;
+  }
+  if (Nrounds > 4) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 5) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 6) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 7) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 7) {
+    X.v[0] += ks[2];
+    X.v[1] += ks[3];
+    X.v[2] += ks[4];
+    X.v[3] += ks[0];
+    X.v[4 - 1] += 2;
+  }
+  if (Nrounds > 8) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 9) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 10) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 11) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 11) {
+    X.v[0] += ks[3];
+    X.v[1] += ks[4];
+    X.v[2] += ks[0];
+    X.v[3] += ks[1];
+    X.v[4 - 1] += 3;
+  }
+  if (Nrounds > 12) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 13) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 14) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 15) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 15) {
+    X.v[0] += ks[4];
+    X.v[1] += ks[0];
+    X.v[2] += ks[1];
+    X.v[3] += ks[2];
+    X.v[4 - 1] += 4;
+  }
+  if (Nrounds > 16) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 17) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 18) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 19) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 19) {
+    X.v[0] += ks[0];
+    X.v[1] += ks[1];
+    X.v[2] += ks[2];
+    X.v[3] += ks[3];
+    X.v[4 - 1] += 5;
+  }
+  if (Nrounds > 20) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 21) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 22) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 23) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 23) {
+    X.v[0] += ks[1];
+    X.v[1] += ks[2];
+    X.v[2] += ks[3];
+    X.v[3] += ks[4];
+    X.v[4 - 1] += 6;
+  }
+  if (Nrounds > 24) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 25) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 26) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 27) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 27) {
+    X.v[0] += ks[2];
+    X.v[1] += ks[3];
+    X.v[2] += ks[4];
+    X.v[3] += ks[0];
+    X.v[4 - 1] += 7;
+  }
+  if (Nrounds > 28) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 29) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 30) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 31) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 31) {
+    X.v[0] += ks[3];
+    X.v[1] += ks[4];
+    X.v[2] += ks[0];
+    X.v[3] += ks[1];
+    X.v[4 - 1] += 8;
+  }
+  if (Nrounds > 32) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 33) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 34) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 35) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 35) {
+    X.v[0] += ks[4];
+    X.v[1] += ks[0];
+    X.v[2] += ks[1];
+    X.v[3] += ks[2];
+    X.v[4 - 1] += 9;
+  }
+  if (Nrounds > 36) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 37) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 38) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 39) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 39) {
+    X.v[0] += ks[0];
+    X.v[1] += ks[1];
+    X.v[2] += ks[2];
+    X.v[3] += ks[3];
+    X.v[4 - 1] += 10;
+  }
+  if (Nrounds > 40) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 41) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 42) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 43) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 43) {
+    X.v[0] += ks[1];
+    X.v[1] += ks[2];
+    X.v[2] += ks[3];
+    X.v[3] += ks[4];
+    X.v[4 - 1] += 11;
+  }
+  if (Nrounds > 44) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 45) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 46) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 47) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 47) {
+    X.v[0] += ks[2];
+    X.v[1] += ks[3];
+    X.v[2] += ks[4];
+    X.v[3] += ks[0];
+    X.v[4 - 1] += 12;
+  }
+  if (Nrounds > 48) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 49) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 50) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 51) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 51) {
+    X.v[0] += ks[3];
+    X.v[1] += ks[4];
+    X.v[2] += ks[0];
+    X.v[3] += ks[1];
+    X.v[4 - 1] += 13;
+  }
+  if (Nrounds > 52) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 53) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 54) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 55) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 55) {
+    X.v[0] += ks[4];
+    X.v[1] += ks[0];
+    X.v[2] += ks[1];
+    X.v[3] += ks[2];
+    X.v[4 - 1] += 14;
+  }
+  if (Nrounds > 56) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 57) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 58) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 59) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 59) {
+    X.v[0] += ks[0];
+    X.v[1] += ks[1];
+    X.v[2] += ks[2];
+    X.v[3] += ks[3];
+    X.v[4 - 1] += 15;
+  }
+  if (Nrounds > 60) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 61) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 62) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 63) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 63) {
+    X.v[0] += ks[1];
+    X.v[1] += ks[2];
+    X.v[2] += ks[3];
+    X.v[3] += ks[4];
+    X.v[4 - 1] += 16;
+  }
+  if (Nrounds > 64) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_0_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_0_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 65) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_1_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_1_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 66) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_2_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_2_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 67) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_3_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_3_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 67) {
+    X.v[0] += ks[2];
+    X.v[1] += ks[3];
+    X.v[2] += ks[4];
+    X.v[3] += ks[0];
+    X.v[4 - 1] += 17;
+  }
+  if (Nrounds > 68) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_4_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_4_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 69) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_5_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_5_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 70) {
+    X.v[0] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_6_0);
+    X.v[1] ^= X.v[0];
+    X.v[2] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_6_1);
+    X.v[3] ^= X.v[2];
+  }
+  if (Nrounds > 71) {
+    X.v[0] += X.v[3];
+    X.v[3] = RotL_32(X.v[3], R_32x4_7_0);
+    X.v[3] ^= X.v[0];
+    X.v[2] += X.v[1];
+    X.v[1] = RotL_32(X.v[1], R_32x4_7_1);
+    X.v[1] ^= X.v[2];
+  }
+  if (Nrounds > 71) {
+    X.v[0] += ks[3];
+    X.v[1] += ks[4];
+    X.v[2] += ks[0];
+    X.v[3] += ks[1];
+    X.v[4 - 1] += 18;
+  }
+  return X;
+}
+enum r123_enum_threefry4x32 { threefry4x32_rounds = 20 };
+static INLINE threefry4x32_ctr_t threefry4x32(threefry4x32_ctr_t in,
+                                              threefry4x32_key_t k);
+static INLINE threefry4x32_ctr_t threefry4x32(threefry4x32_ctr_t in,
+                                              threefry4x32_key_t k) {
+  return threefry4x32_R(threefry4x32_rounds, in, k);
+}
+
+typedef struct s_threefry32_state {
+  threefry4x32_key_t *ctr;
+  threefry4x32_ctr_t *key;
+  int buffer_pos;
+  uint32_t buffer[THREEFRY_BUFFER_SIZE];
+} threefry32_state;
+
+static INLINE uint32_t threefry32_next(threefry32_state *state) {
+  int i;
+  threefry4x32_ctr_t ct;
+  uint32_t out;
+  if (state->buffer_pos < THREEFRY_BUFFER_SIZE) {
+    out = state->buffer[state->buffer_pos];
+    state->buffer_pos++;
+    return out;
+  }
+  /* generate 4 new uint64_t */
+  state->ctr->v[0]++;
+  /* Handle carry */
+  if (state->ctr->v[0] == 0) {
+    state->ctr->v[1]++;
+    if (state->ctr->v[1] == 0) {
+      state->ctr->v[2]++;
+      if (state->ctr->v[2] == 0) {
+        state->ctr->v[3]++;
+      }
+    }
+  }
+  ct = threefry4x32_R(threefry4x32_rounds, *state->ctr, *state->key);
+  for (i = 0; i < 4; i++) {
+    state->buffer[i] = ct.v[i];
+  }
+  state->buffer_pos = 1;
+  return state->buffer[0];
+}
+
+static INLINE uint64_t threefry32_next64(threefry32_state *state) {
+  return ((uint64_t)threefry32_next(state) << 32) | threefry32_next(state);
+}
+
+static INLINE uint32_t threefry32_next32(threefry32_state *state) {
+  return threefry32_next(state);
+}
+
+static INLINE double threefry32_next_double(threefry32_state *state) {
+  int32_t a = threefry32_next(state) >> 5, b = threefry32_next(state) >> 6;
+  return (a * 67108864.0 + b) / 9007199254740992.0;
+}
+
+extern void threefry32_jump(threefry32_state *state);
+
+extern void threefry32_advance(uint32_t *step, threefry32_state *state);
+
+#endif
diff --git a/numpy/random/src/xoroshiro128/LICENSE.md b/numpy/random/src/xoroshiro128/LICENSE.md
new file mode 100644
index 000000000..969430149
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/LICENSE.md
@@ -0,0 +1,9 @@
+# XOROSHIRO128
+
+Written in 2016 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>.
\ No newline at end of file
diff --git a/numpy/random/src/xoroshiro128/xoroshiro128-benchmark.c b/numpy/random/src/xoroshiro128/xoroshiro128-benchmark.c
new file mode 100644
index 000000000..9a7b52bfb
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/xoroshiro128-benchmark.c
@@ -0,0 +1,35 @@
+/*
+ * cl xoroshiro128-benchmark.c xoroshiro128plus.orig.c \
+ * ../splitmix64/splitmix64.c /Ox
+ *
+ * gcc -O3 xoroshiro128-benchmark.c xoroshiro128plus.orig.c \
+ * ../splitmix64/splitmix64.c -o  xoroshiro128-benchmark
+ *
+ */
+#include "../splitmix64/splitmix64.h"
+#include "xoroshiro128plus.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+#include <time.h>
+
+#define N 1000000000
+
+int main()
+{
+  uint64_t count = 0, sum = 0;
+  uint64_t seed = 0xDEADBEAF;
+  s[0] = splitmix64_next(&seed);
+  s[1] = splitmix64_next(&seed);
+  int i;
+  clock_t begin = clock();
+  for (i = 0; i < N; i++)
+  {
+    sum += next();
+    count++;
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(N / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/xoroshiro128/xoroshiro128-test-data-gen.c b/numpy/random/src/xoroshiro128/xoroshiro128-test-data-gen.c
new file mode 100644
index 000000000..d50e63f5e
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/xoroshiro128-test-data-gen.c
@@ -0,0 +1,83 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl xoroshiro128-test-data-gen.c xoroshiro128plus.orig.c /
+ * ../splitmix64/splitmix64.c /Ox
+ * xoroshiro128-test-data-gen.exe *
+ *
+ *  gcc xoroshiro128-test-data-gen.c xoroshiro128plus.orig.c /
+ * ../splitmix64/splitmix64.c -o xoroshiro128-test-data-gen
+ *  ./xoroshiro128-test-data-gen
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "xoroshiro128plus.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main()
+{
+  uint64_t sum = 0;
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  int i;
+  for (i = 0; i < 2; i++)
+  {
+    s[i] = splitmix64_next(&state);
+  }
+  uint64_t store[N];
+  for (i = 0; i < N; i++)
+  {
+    store[i] = next();
+  }
+
+  FILE *fp;
+  fp = fopen("xoroshiro128-testset-1.csv", "w");
+  if (fp == NULL)
+  {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++)
+  {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999)
+    {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  seed = state = 0;
+  for (i = 0; i < 2; i++)
+  {
+    s[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N; i++)
+  {
+    store[i] = next();
+  }
+  fp = fopen("xoroshiro128-testset-2.csv", "w");
+  if (fp == NULL)
+  {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++)
+  {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999)
+    {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/xoroshiro128/xoroshiro128.c b/numpy/random/src/xoroshiro128/xoroshiro128.c
new file mode 100644
index 000000000..060eb8a51
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/xoroshiro128.c
@@ -0,0 +1,60 @@
+/*  Written in 2016-2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+/* This is xoroshiro128+ 1.0, our best and fastest small-state generator
+   for floating-point numbers. We suggest to use its upper bits for
+   floating-point generation, as it is slightly faster than
+   xoroshiro128**. It passes all tests we are aware of except for the four
+   lower bits, which might fail linearity tests (and just those), so if
+   low linear complexity is not considered an issue (as it is usually the
+   case) it can be used to generate 64-bit outputs, too; moreover, this
+   generator has a very mild Hamming-weight dependency making our test
+   (http://prng.di.unimi.it/hwd.php) fail after 5 TB of output; we believe
+   this slight bias cannot affect any application. If you are concerned,
+   use xoroshiro128** or xoshiro256+.
+
+   We suggest to use a sign test to extract a random Boolean value, and
+   right shifts to extract subsets of bits.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s.
+
+   NOTE: the parameters (a=24, b=16, b=37) of this version give slightly
+   better results in our test than the 2016 version (a=55, b=14, c=36).
+*/
+
+#include "xoroshiro128.h"
+
+extern INLINE uint64_t xoroshiro128_next64(xoroshiro128_state *state);
+
+extern INLINE uint32_t xoroshiro128_next32(xoroshiro128_state *state);
+
+void xoroshiro128_jump(xoroshiro128_state *state)
+{
+  int i, b;
+  uint64_t s0;
+  uint64_t s1;
+  static const uint64_t JUMP[] = {0xdf900294d8f554a5, 0x170865df4b3201fc};
+
+  s0 = 0;
+  s1 = 0;
+  for (i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+    for (b = 0; b < 64; b++)
+    {
+      if (JUMP[i] & UINT64_C(1) << b)
+      {
+        s0 ^= state->s[0];
+        s1 ^= state->s[1];
+      }
+      xoroshiro128_next(&state->s[0]);
+    }
+
+  state->s[0] = s0;
+  state->s[1] = s1;
+}
diff --git a/numpy/random/src/xoroshiro128/xoroshiro128.h b/numpy/random/src/xoroshiro128/xoroshiro128.h
new file mode 100644
index 000000000..0db82b173
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/xoroshiro128.h
@@ -0,0 +1,63 @@
+#ifndef _RANDOMDGEN__XOROSHIRO128_H_
+#define _RANDOMDGEN__XOROSHIRO128_H_
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define INLINE __forceinline
+#else
+#include <inttypes.h>
+#define INLINE __inline __forceinline
+#endif
+#else
+#include <inttypes.h>
+#define INLINE inline
+#endif
+
+typedef struct s_xoroshiro128_state
+{
+  uint64_t s[2];
+  int has_uint32;
+  uint32_t uinteger;
+} xoroshiro128_state;
+
+static INLINE uint64_t rotl(const uint64_t x, int k)
+{
+  return (x << k) | (x >> (64 - k));
+}
+
+static INLINE uint64_t xoroshiro128_next(uint64_t *s)
+{
+  const uint64_t s0 = s[0];
+  uint64_t s1 = s[1];
+  const uint64_t result = s0 + s1;
+
+  s1 ^= s0;
+  s[0] = rotl(s0, 24) ^ s1 ^ (s1 << 16); // a, b
+  s[1] = rotl(s1, 37);                   // c
+
+  return result;
+}
+
+static INLINE uint64_t xoroshiro128_next64(xoroshiro128_state *state)
+{
+  return xoroshiro128_next(&state->s[0]);
+}
+
+static INLINE uint32_t xoroshiro128_next32(xoroshiro128_state *state)
+{
+  uint64_t next;
+  if (state->has_uint32)
+  {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = xoroshiro128_next(&state->s[0]);
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
+
+void xoroshiro128_jump(xoroshiro128_state *state);
+
+#endif
diff --git a/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.c b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.c
new file mode 100644
index 000000000..1b5f46e4b
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.c
@@ -0,0 +1,102 @@
+/*  Written in 2016-2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is xoroshiro128+ 1.0, our best and fastest small-state generator
+   for floating-point numbers. We suggest to use its upper bits for
+   floating-point generation, as it is slightly faster than
+   xoroshiro128**. It passes all tests we are aware of except for the four
+   lower bits, which might fail linearity tests (and just those), so if
+   low linear complexity is not considered an issue (as it is usually the
+   case) it can be used to generate 64-bit outputs, too; moreover, this
+   generator has a very mild Hamming-weight dependency making our test
+   (http://prng.di.unimi.it/hwd.php) fail after 5 TB of output; we believe
+   this slight bias cannot affect any application. If you are concerned,
+   use xoroshiro128** or xoshiro256+.
+
+   We suggest to use a sign test to extract a random Boolean value, and
+   right shifts to extract subsets of bits.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s.
+
+   NOTE: the parameters (a=24, b=16, b=37) of this version give slightly
+   better results in our test than the 2016 version (a=55, b=14, c=36).
+*/
+
+uint64_t s[2];
+
+static inline uint64_t rotl(const uint64_t x, int k)
+{
+  return (x << k) | (x >> (64 - k));
+}
+
+uint64_t next(void)
+{
+  const uint64_t s0 = s[0];
+  uint64_t s1 = s[1];
+  const uint64_t result = s0 + s1;
+
+  s1 ^= s0;
+  s[0] = rotl(s0, 24) ^ s1 ^ (s1 << 16); // a, b
+  s[1] = rotl(s1, 37);                   // c
+
+  return result;
+}
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^64 calls to next(); it can be used to generate 2^64
+   non-overlapping subsequences for parallel computations. */
+
+void jump(void)
+{
+  static const uint64_t JUMP[] = {0xdf900294d8f554a5, 0x170865df4b3201fc};
+
+  uint64_t s0 = 0;
+  uint64_t s1 = 0;
+  for (int i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+    for (int b = 0; b < 64; b++)
+    {
+      if (JUMP[i] & UINT64_C(1) << b)
+      {
+        s0 ^= s[0];
+        s1 ^= s[1];
+      }
+      next();
+    }
+  s[0] = s0;
+  s[1] = s1;
+}
+
+/* This is the long-jump function for the generator. It is equivalent to
+   2^96 calls to next(); it can be used to generate 2^32 starting points,
+   from each of which jump() will generate 2^32 non-overlapping
+   subsequences for parallel distributed computations. */
+
+void long_jump(void)
+{
+  static const uint64_t LONG_JUMP[] = {0xd2a98b26625eee7b, 0xdddf9b1090aa7ac1};
+
+  uint64_t s0 = 0;
+  uint64_t s1 = 0;
+  for (int i = 0; i < sizeof LONG_JUMP / sizeof *LONG_JUMP; i++)
+    for (int b = 0; b < 64; b++)
+    {
+      if (LONG_JUMP[i] & UINT64_C(1) << b)
+      {
+        s0 ^= s[0];
+        s1 ^= s[1];
+      }
+      next();
+    }
+
+  s[0] = s0;
+  s[1] = s1;
+}
diff --git a/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.h b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.h
new file mode 100644
index 000000000..20c96fe04
--- /dev/null
+++ b/numpy/random/src/xoroshiro128/xoroshiro128plus.orig.h
@@ -0,0 +1,5 @@
+#include <stdint.h>
+
+uint64_t s[2];
+uint64_t next(void);
+void jump(void);
diff --git a/numpy/random/src/xorshift1024/LICENSE.md b/numpy/random/src/xorshift1024/LICENSE.md
new file mode 100644
index 000000000..3ca8ed4b9
--- /dev/null
+++ b/numpy/random/src/xorshift1024/LICENSE.md
@@ -0,0 +1,9 @@
+# XORSHIFT1024
+
+Written in 2017 by Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>.
\ No newline at end of file
diff --git a/numpy/random/src/xorshift1024/xorshift1024-benchmark.c b/numpy/random/src/xorshift1024/xorshift1024-benchmark.c
new file mode 100644
index 000000000..0eef33537
--- /dev/null
+++ b/numpy/random/src/xorshift1024/xorshift1024-benchmark.c
@@ -0,0 +1,35 @@
+/*
+ * cl xorshift1024-benchmark.c xorshift2014.orig.c
+ *     ../splitmix64/splitmix64.c /Ox
+ *
+ * gcc -O3 xorshift1024-benchmark.c xorshift2014.orig.c /
+ * ../splitmix64/splitmix64.c -o xorshift1024-benchmark
+ *
+ */
+#include "../splitmix64/splitmix64.h"
+#include "xorshift1024.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+#include <time.h>
+
+#define N 1000000000
+
+int main() {
+  uint64_t count = 0, sum = 0;
+  uint64_t seed = 0xDEADBEAF;
+  int i;
+  for (i = 0; i < 16; i++) {
+    s[i] = splitmix64_next(&seed);
+  }
+  p = 0;
+  clock_t begin = clock();
+  for (i = 0; i < N; i++) {
+    sum += next();
+    count++;
+  }
+  clock_t end = clock();
+  double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
+  printf("0x%" PRIx64 "\ncount: %" PRIu64 "\n", sum, count);
+  printf("%" PRIu64 " randoms per second\n",
+         (uint64_t)(N / time_spent) / 1000000 * 1000000);
+}
diff --git a/numpy/random/src/xorshift1024/xorshift1024-test-data-gen.c b/numpy/random/src/xorshift1024/xorshift1024-test-data-gen.c
new file mode 100644
index 000000000..a2ae08df4
--- /dev/null
+++ b/numpy/random/src/xorshift1024/xorshift1024-test-data-gen.c
@@ -0,0 +1,74 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl xorshift1024-test-data-gen.c xorshift1024.orig.c /
+ * ../splitmix64/splitmix64.c /Ox
+ * xorshift1024-test-data-gen.exe *
+ *
+ *  gcc xorshift1024-test-data-gen.c xorshift1024.orig.c /
+ * ../splitmix64/splitmix64.c -o xorshift1024-test-data-gen
+ *  ./xorshift1024-test-data-gen
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "xorshift1024.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  uint64_t sum = 0;
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  int i;
+  for (i = 0; i < 16; i++) {
+    s[i] = splitmix64_next(&state);
+  }
+  p = 0;
+  uint64_t store[N];
+  for (i = 0; i < N; i++) {
+    store[i] = next();
+  }
+
+  FILE *fp;
+  fp = fopen("xorshift1024-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  seed = state = 0;
+  for (i = 0; i < 16; i++) {
+    s[i] = splitmix64_next(&state);
+  }
+  p = 0;
+  for (i = 0; i < N; i++) {
+    store[i] = next();
+  }
+  fp = fopen("xorshift1024-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/xorshift1024/xorshift1024.c b/numpy/random/src/xorshift1024/xorshift1024.c
new file mode 100644
index 000000000..8737b5a82
--- /dev/null
+++ b/numpy/random/src/xorshift1024/xorshift1024.c
@@ -0,0 +1,32 @@
+#include "xorshift1024.h"
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^512 calls to next(); it can be used to generate 2^512
+   non-overlapping subsequences for parallel computations. */
+
+extern INLINE uint64_t xorshift1024_next(xorshift1024_state *state);
+extern INLINE uint64_t xorshift1024_next64(xorshift1024_state *state);
+extern INLINE uint32_t xorshift1024_next32(xorshift1024_state *state);
+
+void xorshift1024_jump(xorshift1024_state *state) {
+  int i, j, b;
+  static const uint64_t JUMP[] = {
+      0x84242f96eca9c41d, 0xa3c65b8776f96855, 0x5b34a39f070b5837,
+      0x4489affce4f31a1e, 0x2ffeeb0a48316f40, 0xdc2d9891fe68c022,
+      0x3659132bb12fea70, 0xaac17d8efa43cab8, 0xc4cb815590989b13,
+      0x5ee975283d71c93b, 0x691548c86c1bd540, 0x7910c41d10a1e6a5,
+      0x0b5fc64563b3e2a8, 0x047f7684e9fc949d, 0xb99181f2d8f685ca,
+      0x284600e3f30e38c3};
+
+  uint64_t t[16] = {0};
+  for (i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+    for (b = 0; b < 64; b++) {
+      if (JUMP[i] & UINT64_C(1) << b)
+        for (j = 0; j < 16; j++)
+          t[j] ^= state->s[(j + state->p) & 15];
+      xorshift1024_next(state);
+    }
+
+  for (j = 0; j < 16; j++)
+    state->s[(j + state->p) & 15] = t[j];
+}
diff --git a/numpy/random/src/xorshift1024/xorshift1024.h b/numpy/random/src/xorshift1024/xorshift1024.h
new file mode 100644
index 000000000..e0ef77826
--- /dev/null
+++ b/numpy/random/src/xorshift1024/xorshift1024.h
@@ -0,0 +1,50 @@
+#ifndef _RANDOMDGEN__XORSHIFT1024_H_
+#define _RANDOMDGEN__XORSHIFT1024_H_
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define INLINE __forceinline
+#else
+#include <inttypes.h>
+#define INLINE __inline __forceinline
+#endif
+#else
+#include <inttypes.h>
+#define INLINE inline
+#endif
+
+typedef struct s_xorshift1024_state {
+  uint64_t s[16];
+  int p;
+  int has_uint32;
+  uint32_t uinteger;
+} xorshift1024_state;
+
+static INLINE uint64_t xorshift1024_next(xorshift1024_state *state) {
+  const uint64_t s0 = state->s[state->p];
+  uint64_t s1 = state->s[state->p = ((state->p) + 1) & 15];
+  s1 ^= s1 << 31;                                         // a
+  state->s[state->p] = s1 ^ s0 ^ (s1 >> 11) ^ (s0 >> 30); // b,c
+  return state->s[state->p] * 0x9e3779b97f4a7c13;
+}
+
+static INLINE uint64_t xorshift1024_next64(xorshift1024_state *state) {
+  return xorshift1024_next(state);
+}
+
+static INLINE uint32_t xorshift1024_next32(xorshift1024_state *state) {
+  uint64_t next;
+  if (state->has_uint32) {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = xorshift1024_next(state);
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
+
+void xorshift1024_jump(xorshift1024_state *state);
+
+#endif
diff --git a/numpy/random/src/xorshift1024/xorshift1024.orig.c b/numpy/random/src/xorshift1024/xorshift1024.orig.c
new file mode 100644
index 000000000..03c1c17fe
--- /dev/null
+++ b/numpy/random/src/xorshift1024/xorshift1024.orig.c
@@ -0,0 +1,68 @@
+/*  Written in 2017 by Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+#include <string.h>
+
+/* NOTE: as of 2017-10-08, this generator has a different multiplier (a
+   fixed-point representation of the golden ratio), which eliminates
+   linear dependencies from one of the lowest bits. The previous
+   multiplier was 1181783497276652981 (M_8 in the paper). If you need to
+   tell apart the two generators, you can refer to this generator as
+   xorshift1024φ and to the previous one as xorshift1024*M_8.
+
+   This is a fast, high-quality generator. If 1024 bits of state are too
+   much, try a xoroshiro128+ generator.
+
+   Note that the two lowest bits of this generator are LFSRs of degree
+   1024, and thus will fail binary rank tests. The other bits needs a much
+   higher degree to be represented as LFSRs.
+
+   We suggest to use a sign test to extract a random Boolean value, and
+   right shifts to extract subsets of bits.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s. */
+
+uint64_t s[16];
+int p;
+
+uint64_t next(void) {
+  const uint64_t s0 = s[p];
+  uint64_t s1 = s[p = (p + 1) & 15];
+  s1 ^= s1 << 31; // a
+  s[p] = s1 ^ s0 ^ (s1 >> 11) ^ (s0 >> 30); // b,c
+  return s[p] * 0x9e3779b97f4a7c13;
+}
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^512 calls to next(); it can be used to generate 2^512
+   non-overlapping subsequences for parallel computations. */
+
+void jump(void) {
+  static const uint64_t JUMP[] = {
+      0x84242f96eca9c41d, 0xa3c65b8776f96855, 0x5b34a39f070b5837,
+      0x4489affce4f31a1e, 0x2ffeeb0a48316f40, 0xdc2d9891fe68c022,
+      0x3659132bb12fea70, 0xaac17d8efa43cab8, 0xc4cb815590989b13,
+      0x5ee975283d71c93b, 0x691548c86c1bd540, 0x7910c41d10a1e6a5,
+      0x0b5fc64563b3e2a8, 0x047f7684e9fc949d, 0xb99181f2d8f685ca,
+      0x284600e3f30e38c3};
+
+  uint64_t t[16] = {0};
+  for (int i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+    for (int b = 0; b < 64; b++) {
+      if (JUMP[i] & UINT64_C(1) << b)
+        for (int j = 0; j < 16; j++)
+          t[j] ^= s[(j + p) & 15];
+      next();
+    }
+
+  for (int j = 0; j < 16; j++)
+    s[(j + p) & 15] = t[j];
+}
diff --git a/numpy/random/src/xorshift1024/xorshift1024.orig.h b/numpy/random/src/xorshift1024/xorshift1024.orig.h
new file mode 100644
index 000000000..9b7597967
--- /dev/null
+++ b/numpy/random/src/xorshift1024/xorshift1024.orig.h
@@ -0,0 +1,7 @@
+#include <stdint.h>
+#include <string.h>
+
+uint64_t s[16];
+int p;
+uint64_t next(void);
+void jump(void);
diff --git a/numpy/random/src/xoshiro256starstar/LICENSE.md b/numpy/random/src/xoshiro256starstar/LICENSE.md
new file mode 100644
index 000000000..d863f3b29
--- /dev/null
+++ b/numpy/random/src/xoshiro256starstar/LICENSE.md
@@ -0,0 +1,9 @@
+# XOSHIRO256STARSTAR
+
+Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>.
\ No newline at end of file
diff --git a/numpy/random/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c b/numpy/random/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c
new file mode 100644
index 000000000..8522229dd
--- /dev/null
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar-test-data-gen.c
@@ -0,0 +1,72 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl xoshiro256starstar-test-data-gen.c xoshiro256starstar.orig.c /
+ * ../splitmix64/splitmix64.c /Ox
+ * xoshiro256starstar-test-data-gen.exe *
+ *
+ *  gcc xoshiro256starstar-test-data-gen.c xoshiro256starstar.orig.c /
+ * ../splitmix64/splitmix64.c -o xoshiro256starstar-test-data-gen
+ *  ./xoshiro256starstar-test-data-gen
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "xoshiro256starstar.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  uint64_t sum = 0;
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  int i;
+  for (i = 0; i < 4; i++) {
+    s[i] = splitmix64_next(&state);
+  }
+  uint64_t store[N];
+  for (i = 0; i < N; i++) {
+    store[i] = next();
+  }
+
+  FILE *fp;
+  fp = fopen("xoshiro256starstar-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  seed = state = 0;
+  for (i = 0; i < 4; i++) {
+    s[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N; i++) {
+    store[i] = next();
+  }
+  fp = fopen("xoshiro256starstar-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/xoshiro256starstar/xoshiro256starstar.c b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.c
new file mode 100644
index 000000000..30b6c7d85
--- /dev/null
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.c
@@ -0,0 +1,55 @@
+/*  Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include "xoshiro256starstar.h"
+
+/* This is xoshiro256** 1.0, our all-purpose, rock-solid generator. It has
+   excellent (sub-ns) speed, a state (256 bits) that is large enough for
+   any parallel application, and it passes all tests we are aware of.
+
+   For generating just floating-point numbers, xoshiro256+ is even faster.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s. */
+
+extern INLINE uint64_t xoshiro256starstar_next64(xoshiro256starstar_state *state);
+
+extern INLINE uint32_t xoshiro256starstar_next32(xoshiro256starstar_state *state);
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^128 calls to next(); it can be used to generate 2^128
+   non-overlapping subsequences for parallel computations. */
+
+void xoshiro256starstar_jump(xoshiro256starstar_state *state)
+{
+	int i, b;
+	static const uint64_t JUMP[] = {0x180ec6d33cfd0aba, 0xd5a61266f0c9392c, 0xa9582618e03fc9aa, 0x39abdc4529b1661c};
+
+	uint64_t s0 = 0;
+	uint64_t s1 = 0;
+	uint64_t s2 = 0;
+	uint64_t s3 = 0;
+	for (i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+		for (b = 0; b < 64; b++)
+		{
+			if (JUMP[i] & UINT64_C(1) << b)
+			{
+				s0 ^= state->s[0];
+				s1 ^= state->s[1];
+				s2 ^= state->s[2];
+				s3 ^= state->s[3];
+			}
+			xoshiro256starstar_next(&state->s[0]);
+		}
+
+	state->s[0] = s0;
+	state->s[1] = s1;
+	state->s[2] = s2;
+	state->s[3] = s3;
+}
diff --git a/numpy/random/src/xoshiro256starstar/xoshiro256starstar.h b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.h
new file mode 100644
index 000000000..1d7d8ea40
--- /dev/null
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.h
@@ -0,0 +1,63 @@
+#ifndef _RANDOMDGEN__XOSHIRO256STARSTAR_H_
+#define _RANDOMDGEN__XOSHIRO256STARSTAR_H_
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define INLINE __forceinline
+#else
+#include <inttypes.h>
+#define INLINE __inline __forceinline
+#endif
+#else
+#include <inttypes.h>
+#define INLINE inline
+#endif
+
+typedef struct s_xoshiro256starstar_state {
+  uint64_t s[4];
+  int has_uint32;
+  uint32_t uinteger;
+} xoshiro256starstar_state;
+
+static INLINE uint64_t rotl(const uint64_t x, int k) {
+  return (x << k) | (x >> (64 - k));
+}
+
+static INLINE uint64_t xoshiro256starstar_next(uint64_t *s) {
+  const uint64_t result_starstar = rotl(s[1] * 5, 7) * 9;
+  const uint64_t t = s[1] << 17;
+
+  s[2] ^= s[0];
+  s[3] ^= s[1];
+  s[1] ^= s[2];
+  s[0] ^= s[3];
+
+  s[2] ^= t;
+
+  s[3] = rotl(s[3], 45);
+
+  return result_starstar;
+}
+
+static INLINE uint64_t
+xoshiro256starstar_next64(xoshiro256starstar_state *state) {
+  return xoshiro256starstar_next(&state->s[0]);
+}
+
+static INLINE uint32_t
+xoshiro256starstar_next32(xoshiro256starstar_state *state) {
+  uint64_t next;
+  if (state->has_uint32) {
+    state->has_uint32 = 0;
+    return state->uinteger;
+  }
+  next = xoshiro256starstar_next(&state->s[0]);
+  state->has_uint32 = 1;
+  state->uinteger = (uint32_t)(next >> 32);
+  return (uint32_t)(next & 0xffffffff);
+}
+
+void xoshiro256starstar_jump(xoshiro256starstar_state *state);
+
+#endif
diff --git a/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.c b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.c
new file mode 100644
index 000000000..ecf87bab9
--- /dev/null
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.c
@@ -0,0 +1,103 @@
+/*  Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include <stdint.h>
+
+/* This is xoshiro256** 1.0, our all-purpose, rock-solid generator. It has
+   excellent (sub-ns) speed, a state (256 bits) that is large enough for
+   any parallel application, and it passes all tests we are aware of.
+
+   For generating just floating-point numbers, xoshiro256+ is even faster.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s. */
+
+static inline uint64_t rotl(const uint64_t x, int k) {
+	return (x << k) | (x >> (64 - k));
+}
+
+
+uint64_t s[4];
+
+uint64_t next(void) {
+	const uint64_t result_starstar = rotl(s[1] * 5, 7) * 9;
+
+	const uint64_t t = s[1] << 17;
+
+	s[2] ^= s[0];
+	s[3] ^= s[1];
+	s[1] ^= s[2];
+	s[0] ^= s[3];
+
+	s[2] ^= t;
+
+	s[3] = rotl(s[3], 45);
+
+	return result_starstar;
+}
+
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^128 calls to next(); it can be used to generate 2^128
+   non-overlapping subsequences for parallel computations. */
+
+void jump(void) {
+	static const uint64_t JUMP[] = { 0x180ec6d33cfd0aba, 0xd5a61266f0c9392c, 0xa9582618e03fc9aa, 0x39abdc4529b1661c };
+
+	uint64_t s0 = 0;
+	uint64_t s1 = 0;
+	uint64_t s2 = 0;
+	uint64_t s3 = 0;
+	for(int i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+		for(int b = 0; b < 64; b++) {
+			if (JUMP[i] & UINT64_C(1) << b) {
+				s0 ^= s[0];
+				s1 ^= s[1];
+				s2 ^= s[2];
+				s3 ^= s[3];
+			}
+			next();	
+		}
+		
+	s[0] = s0;
+	s[1] = s1;
+	s[2] = s2;
+	s[3] = s3;
+}
+
+
+
+/* This is the long-jump function for the generator. It is equivalent to
+   2^192 calls to next(); it can be used to generate 2^64 starting points,
+   from each of which jump() will generate 2^64 non-overlapping
+   subsequences for parallel distributed computations. */
+
+void long_jump(void) {
+	static const uint64_t LONG_JUMP[] = { 0x76e15d3efefdcbbf, 0xc5004e441c522fb3, 0x77710069854ee241, 0x39109bb02acbe635 };
+
+	uint64_t s0 = 0;
+	uint64_t s1 = 0;
+	uint64_t s2 = 0;
+	uint64_t s3 = 0;
+	for(int i = 0; i < sizeof LONG_JUMP / sizeof *LONG_JUMP; i++)
+		for(int b = 0; b < 64; b++) {
+			if (LONG_JUMP[i] & UINT64_C(1) << b) {
+				s0 ^= s[0];
+				s1 ^= s[1];
+				s2 ^= s[2];
+				s3 ^= s[3];
+			}
+			next();	
+		}
+		
+	s[0] = s0;
+	s[1] = s1;
+	s[2] = s2;
+	s[3] = s3;
+}
\ No newline at end of file
diff --git a/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.h b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.h
new file mode 100644
index 000000000..3aa788ec9
--- /dev/null
+++ b/numpy/random/src/xoshiro256starstar/xoshiro256starstar.orig.h
@@ -0,0 +1,5 @@
+#include <stdint.h>
+
+uint64_t s[4];
+uint64_t next(void);
+void jump(void);
diff --git a/numpy/random/src/xoshiro512starstar/LICENSE.md b/numpy/random/src/xoshiro512starstar/LICENSE.md
new file mode 100644
index 000000000..aa34c1966
--- /dev/null
+++ b/numpy/random/src/xoshiro512starstar/LICENSE.md
@@ -0,0 +1,9 @@
+# XOSHIRO512STARSTAR
+
+Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>.
diff --git a/numpy/random/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c b/numpy/random/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c
new file mode 100644
index 000000000..bcc3574e4
--- /dev/null
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar-test-data-gen.c
@@ -0,0 +1,72 @@
+/*
+ * Generate testing csv files
+ *
+ *  cl xoshiro512starstar-test-data-gen.c xoshiro512starstar.orig.c /
+ * ../splitmix64/splitmix64.c /Ox
+ * xoshiro512starstar-test-data-gen.exe *
+ *
+ *  gcc xoshiro512starstar-test-data-gen.c xoshiro512starstar.orig.c /
+ * ../splitmix64/splitmix64.c -o xoshiro512starstar-test-data-gen
+ *  ./xoshiro512starstar-test-data-gen
+ *
+ * Requres the Random123 directory containing header files to be located in the
+ * same directory (not included).
+ *
+ */
+
+#include "../splitmix64/splitmix64.h"
+#include "xoshiro512starstar.orig.h"
+#include <inttypes.h>
+#include <stdio.h>
+
+#define N 1000
+
+int main() {
+  uint64_t sum = 0;
+  uint64_t state, seed = 0xDEADBEAF;
+  state = seed;
+  int i;
+  for (i = 0; i < 8; i++) {
+    s[i] = splitmix64_next(&state);
+  }
+  uint64_t store[N];
+  for (i = 0; i < N; i++) {
+    store[i] = next();
+  }
+
+  FILE *fp;
+  fp = fopen("xoshiro512starstar-testset-1.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+
+  seed = state = 0;
+  for (i = 0; i < 8; i++) {
+    s[i] = splitmix64_next(&state);
+  }
+  for (i = 0; i < N; i++) {
+    store[i] = next();
+  }
+  fp = fopen("xoshiro512starstar-testset-2.csv", "w");
+  if (fp == NULL) {
+    printf("Couldn't open file\n");
+    return -1;
+  }
+  fprintf(fp, "seed, 0x%" PRIx64 "\n", seed);
+  for (i = 0; i < N; i++) {
+    fprintf(fp, "%d, 0x%" PRIx64 "\n", i, store[i]);
+    if (i == 999) {
+      printf("%d, 0x%" PRIx64 "\n", i, store[i]);
+    }
+  }
+  fclose(fp);
+}
diff --git a/numpy/random/src/xoshiro512starstar/xoshiro512starstar.c b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.c
new file mode 100644
index 000000000..a9f56699f
--- /dev/null
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.c
@@ -0,0 +1,53 @@
+/*  Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include "xoshiro512starstar.h"
+
+/* This is xoshiro512** 1.0, an all-purpose, rock-solid generator. It has
+   excellent (about 1ns) speed, an increased state (512 bits) that is
+   large enough for any parallel application, and it passes all tests we
+   are aware of.
+
+   For generating just floating-point numbers, xoshiro512+ is even faster.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s. */
+
+extern INLINE uint64_t
+xoshiro512starstar_next64(xoshiro512starstar_state *state);
+
+extern INLINE uint32_t
+xoshiro512starstar_next32(xoshiro512starstar_state *state);
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^256 calls to next(); it can be used to generate 2^256
+   non-overlapping subsequences for parallel computations. */
+
+static uint64_t s_placeholder[8];
+
+void xoshiro512starstar_jump(xoshiro512starstar_state *state) {
+
+  int i, b, w;
+  static const uint64_t JUMP[] = {0x33ed89b6e7a353f9, 0x760083d7955323be,
+                                  0x2837f2fbb5f22fae, 0x4b8c5674d309511c,
+                                  0xb11ac47a7ba28c25, 0xf1be7667092bcc1c,
+                                  0x53851efdb6df0aaf, 0x1ebbc8b23eaf25db};
+
+  uint64_t t[sizeof s_placeholder / sizeof *s_placeholder];
+  memset(t, 0, sizeof t);
+  for (i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+    for (b = 0; b < 64; b++) {
+      if (JUMP[i] & UINT64_C(1) << b)
+        for (w = 0; w < sizeof s_placeholder / sizeof *s_placeholder; w++)
+          t[w] ^= state->s[w];
+      xoshiro512starstar_next(&state->s[0]);
+    }
+
+  memcpy(state->s, t, sizeof s_placeholder);
+}
diff --git a/numpy/random/src/xoshiro512starstar/xoshiro512starstar.h b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.h
new file mode 100644
index 000000000..0fa0ba3cd
--- /dev/null
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.h
@@ -0,0 +1,75 @@
+#ifndef _RANDOMDGEN__XOSHIRO512STARSTAR_H_
+#define _RANDOMDGEN__XOSHIRO512STARSTAR_H_
+
+#ifdef _WIN32
+#if _MSC_VER == 1500
+#include "../common/inttypes.h"
+#define INLINE __forceinline
+#else
+#include <inttypes.h>
+#define INLINE __inline __forceinline
+#endif
+#else
+#include <inttypes.h>
+#define INLINE inline
+#endif
+#include <string.h>
+
+typedef struct s_xoshiro512starstar_state
+{
+	uint64_t s[8];
+	int has_uint32;
+	uint32_t uinteger;
+} xoshiro512starstar_state;
+
+static INLINE uint64_t rotl(const uint64_t x, int k)
+{
+	return (x << k) | (x >> (64 - k));
+}
+
+static INLINE uint64_t xoshiro512starstar_next(uint64_t *s)
+{
+	const uint64_t result_starstar = rotl(s[1] * 5, 7) * 9;
+
+	const uint64_t t = s[1] << 11;
+
+	s[2] ^= s[0];
+	s[5] ^= s[1];
+	s[1] ^= s[2];
+	s[7] ^= s[3];
+	s[3] ^= s[4];
+	s[4] ^= s[5];
+	s[0] ^= s[6];
+	s[6] ^= s[7];
+
+	s[6] ^= t;
+
+	s[7] = rotl(s[7], 21);
+
+	return result_starstar;
+}
+
+static INLINE uint64_t
+xoshiro512starstar_next64(xoshiro512starstar_state *state)
+{
+	return xoshiro512starstar_next(&state->s[0]);
+}
+
+static INLINE uint32_t
+xoshiro512starstar_next32(xoshiro512starstar_state *state)
+{
+	uint64_t next;
+	if (state->has_uint32)
+	{
+		state->has_uint32 = 0;
+		return state->uinteger;
+	}
+	next = xoshiro512starstar_next(&state->s[0]);
+	state->has_uint32 = 1;
+	state->uinteger = (uint32_t)(next >> 32);
+	return (uint32_t)(next & 0xffffffff);
+}
+
+void xoshiro512starstar_jump(xoshiro512starstar_state *state);
+
+#endif
diff --git a/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.c b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.c
new file mode 100644
index 000000000..0cf884edb
--- /dev/null
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.c
@@ -0,0 +1,67 @@
+/*  Written in 2018 by David Blackman and Sebastiano Vigna (vigna@acm.org)
+
+To the extent possible under law, the author has dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+
+See <http://creativecommons.org/publicdomain/zero/1.0/>. */
+
+#include "xoshiro512starstar.orig.h"
+
+/* This is xoshiro512** 1.0, an all-purpose, rock-solid generator. It has
+   excellent (about 1ns) speed, an increased state (512 bits) that is
+   large enough for any parallel application, and it passes all tests we
+   are aware of.
+
+   For generating just floating-point numbers, xoshiro512+ is even faster.
+
+   The state must be seeded so that it is not everywhere zero. If you have
+   a 64-bit seed, we suggest to seed a splitmix64 generator and use its
+   output to fill s. */
+
+static inline uint64_t rotl(const uint64_t x, int k) {
+	return (x << k) | (x >> (64 - k));
+}
+
+
+uint64_t next(void) {
+	const uint64_t result_starstar = rotl(s[1] * 5, 7) * 9;
+
+	const uint64_t t = s[1] << 11;
+
+	s[2] ^= s[0];
+	s[5] ^= s[1];
+	s[1] ^= s[2];
+	s[7] ^= s[3];
+	s[3] ^= s[4];
+	s[4] ^= s[5];
+	s[0] ^= s[6];
+	s[6] ^= s[7];
+
+	s[6] ^= t;
+
+	s[7] = rotl(s[7], 21);
+
+	return result_starstar;
+}
+
+
+/* This is the jump function for the generator. It is equivalent
+   to 2^256 calls to next(); it can be used to generate 2^256
+   non-overlapping subsequences for parallel computations. */
+
+void jump(void) {
+	static const uint64_t JUMP[] = { 0x33ed89b6e7a353f9, 0x760083d7955323be, 0x2837f2fbb5f22fae, 0x4b8c5674d309511c, 0xb11ac47a7ba28c25, 0xf1be7667092bcc1c, 0x53851efdb6df0aaf, 0x1ebbc8b23eaf25db };
+
+	uint64_t t[sizeof s / sizeof *s];
+	memset(t, 0, sizeof t);
+	for(int i = 0; i < sizeof JUMP / sizeof *JUMP; i++)
+		for(int b = 0; b < 64; b++) {
+			if (JUMP[i] & UINT64_C(1) << b)
+				for(int w = 0; w < sizeof s / sizeof *s; w++)
+					t[w] ^= s[w];
+			next();
+		}
+
+	memcpy(s, t, sizeof s);
+}
\ No newline at end of file
diff --git a/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.h b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.h
new file mode 100644
index 000000000..0b7892473
--- /dev/null
+++ b/numpy/random/src/xoshiro512starstar/xoshiro512starstar.orig.h
@@ -0,0 +1,6 @@
+#include <stdint.h>
+#include <string.h>
+
+uint64_t s[8];
+uint64_t next(void);
+void jump(void);