Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/__ufunc_api.c

@@ -0,0 +1,50 @@
+
+/* These pointers will be stored in the C-object for use in other
+    extension modules
+*/
+
+void *PyUFunc_API[] = {
+        (void *) &PyUFunc_Type,
+        (void *) PyUFunc_FromFuncAndData,
+        (void *) PyUFunc_RegisterLoopForType,
+        (void *) PyUFunc_GenericFunction,
+        (void *) PyUFunc_f_f_As_d_d,
+        (void *) PyUFunc_d_d,
+        (void *) PyUFunc_f_f,
+        (void *) PyUFunc_g_g,
+        (void *) PyUFunc_F_F_As_D_D,
+        (void *) PyUFunc_F_F,
+        (void *) PyUFunc_D_D,
+        (void *) PyUFunc_G_G,
+        (void *) PyUFunc_O_O,
+        (void *) PyUFunc_ff_f_As_dd_d,
+        (void *) PyUFunc_ff_f,
+        (void *) PyUFunc_dd_d,
+        (void *) PyUFunc_gg_g,
+        (void *) PyUFunc_FF_F_As_DD_D,
+        (void *) PyUFunc_DD_D,
+        (void *) PyUFunc_FF_F,
+        (void *) PyUFunc_GG_G,
+        (void *) PyUFunc_OO_O,
+        (void *) PyUFunc_O_O_method,
+        (void *) PyUFunc_OO_O_method,
+        (void *) PyUFunc_On_Om,
+        (void *) PyUFunc_GetPyValues,
+        (void *) PyUFunc_checkfperr,
+        (void *) PyUFunc_clearfperr,
+        (void *) PyUFunc_getfperr,
+        (void *) PyUFunc_handlefperr,
+        (void *) PyUFunc_ReplaceLoopBySignature,
+        (void *) PyUFunc_FromFuncAndDataAndSignature,
+        (void *) PyUFunc_SetUsesArraysAsData,
+        (void *) PyUFunc_e_e,
+        (void *) PyUFunc_e_e_As_f_f,
+        (void *) PyUFunc_e_e_As_d_d,
+        (void *) PyUFunc_ee_e,
+        (void *) PyUFunc_ee_e_As_ff_f,
+        (void *) PyUFunc_ee_e_As_dd_d,
+        (void *) PyUFunc_DefaultTypeResolver,
+        (void *) PyUFunc_ValidateCasting,
+        (void *) PyUFunc_RegisterLoopForDescr,
+        (void *) PyUFunc_FromFuncAndDataAndSignatureAndIdentity
+};

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/_neighborhood_iterator_imp.h

@@ -0,0 +1,90 @@
+#ifndef NUMPY_CORE_INCLUDE_NUMPY__NEIGHBORHOOD_IMP_H_
+#error You should not include this header directly
+#endif
+/*
+ * Private API (here for inline)
+ */
+static inline int
+_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter);
+
+/*
+ * Update to next item of the iterator
+ *
+ * Note: this simply increment the coordinates vector, last dimension
+ * incremented first , i.e, for dimension 3
+ * ...
+ * -1, -1, -1
+ * -1, -1,  0
+ * -1, -1,  1
+ *  ....
+ * -1,  0, -1
+ * -1,  0,  0
+ *  ....
+ * 0,  -1, -1
+ * 0,  -1,  0
+ *  ....
+ */
+#define _UPDATE_COORD_ITER(c) \
+    wb = iter->coordinates[c] < iter->bounds[c][1]; \
+    if (wb) { \
+        iter->coordinates[c] += 1; \
+        return 0; \
+    } \
+    else { \
+        iter->coordinates[c] = iter->bounds[c][0]; \
+    }
+
+static inline int
+_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter)
+{
+    npy_intp i, wb;
+
+    for (i = iter->nd - 1; i >= 0; --i) {
+        _UPDATE_COORD_ITER(i)
+    }
+
+    return 0;
+}
+
+/*
+ * Version optimized for 2d arrays, manual loop unrolling
+ */
+static inline int
+_PyArrayNeighborhoodIter_IncrCoord2D(PyArrayNeighborhoodIterObject* iter)
+{
+    npy_intp wb;
+
+    _UPDATE_COORD_ITER(1)
+    _UPDATE_COORD_ITER(0)
+
+    return 0;
+}
+#undef _UPDATE_COORD_ITER
+
+/*
+ * Advance to the next neighbour
+ */
+static inline int
+PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)
+{
+    _PyArrayNeighborhoodIter_IncrCoord (iter);
+    iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates);
+
+    return 0;
+}
+
+/*
+ * Reset functions
+ */
+static inline int
+PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter)
+{
+    npy_intp i;
+
+    for (i = 0; i < iter->nd; ++i) {
+        iter->coordinates[i] = iter->bounds[i][0];
+    }
+    iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates);
+
+    return 0;
+}

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/npy_1_7_deprecated_api.h

@@ -0,0 +1,124 @@
+#ifndef NPY_DEPRECATED_INCLUDES
+#error "Should never include npy_*_*_deprecated_api directly."
+#endif
+
+#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_
+#define NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_
+
+/* Emit a warning if the user did not specifically request the old API */
+#ifndef NPY_NO_DEPRECATED_API
+#if defined(_WIN32)
+#define _WARN___STR2__(x) #x
+#define _WARN___STR1__(x) _WARN___STR2__(x)
+#define _WARN___LOC__ __FILE__ "(" _WARN___STR1__(__LINE__) ") : Warning Msg: "
+#pragma message(_WARN___LOC__"Using deprecated NumPy API, disable it with " \
+                         "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION")
+#else
+#warning "Using deprecated NumPy API, disable it with " \
+         "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION"
+#endif
+#endif
+
+/*
+ * This header exists to collect all dangerous/deprecated NumPy API
+ * as of NumPy 1.7.
+ *
+ * This is an attempt to remove bad API, the proliferation of macros,
+ * and namespace pollution currently produced by the NumPy headers.
+ */
+
+/* These array flags are deprecated as of NumPy 1.7 */
+#define NPY_CONTIGUOUS NPY_ARRAY_C_CONTIGUOUS
+#define NPY_FORTRAN NPY_ARRAY_F_CONTIGUOUS
+
+/*
+ * The consistent NPY_ARRAY_* names which don't pollute the NPY_*
+ * namespace were added in NumPy 1.7.
+ *
+ * These versions of the carray flags are deprecated, but
+ * probably should only be removed after two releases instead of one.
+ */
+#define NPY_C_CONTIGUOUS   NPY_ARRAY_C_CONTIGUOUS
+#define NPY_F_CONTIGUOUS   NPY_ARRAY_F_CONTIGUOUS
+#define NPY_OWNDATA        NPY_ARRAY_OWNDATA
+#define NPY_FORCECAST      NPY_ARRAY_FORCECAST
+#define NPY_ENSURECOPY     NPY_ARRAY_ENSURECOPY
+#define NPY_ENSUREARRAY    NPY_ARRAY_ENSUREARRAY
+#define NPY_ELEMENTSTRIDES NPY_ARRAY_ELEMENTSTRIDES
+#define NPY_ALIGNED        NPY_ARRAY_ALIGNED
+#define NPY_NOTSWAPPED     NPY_ARRAY_NOTSWAPPED
+#define NPY_WRITEABLE      NPY_ARRAY_WRITEABLE
+#define NPY_BEHAVED        NPY_ARRAY_BEHAVED
+#define NPY_BEHAVED_NS     NPY_ARRAY_BEHAVED_NS
+#define NPY_CARRAY         NPY_ARRAY_CARRAY
+#define NPY_CARRAY_RO      NPY_ARRAY_CARRAY_RO
+#define NPY_FARRAY         NPY_ARRAY_FARRAY
+#define NPY_FARRAY_RO      NPY_ARRAY_FARRAY_RO
+#define NPY_DEFAULT        NPY_ARRAY_DEFAULT
+#define NPY_IN_ARRAY       NPY_ARRAY_IN_ARRAY
+#define NPY_OUT_ARRAY      NPY_ARRAY_OUT_ARRAY
+#define NPY_INOUT_ARRAY    NPY_ARRAY_INOUT_ARRAY
+#define NPY_IN_FARRAY      NPY_ARRAY_IN_FARRAY
+#define NPY_OUT_FARRAY     NPY_ARRAY_OUT_FARRAY
+#define NPY_INOUT_FARRAY   NPY_ARRAY_INOUT_FARRAY
+#define NPY_UPDATE_ALL     NPY_ARRAY_UPDATE_ALL
+
+/* This way of accessing the default type is deprecated as of NumPy 1.7 */
+#define PyArray_DEFAULT NPY_DEFAULT_TYPE
+
+/* These DATETIME bits aren't used internally */
+#define PyDataType_GetDatetimeMetaData(descr)                                 \
+    ((descr->metadata == NULL) ? NULL :                                       \
+        ((PyArray_DatetimeMetaData *)(PyCapsule_GetPointer(                   \
+                PyDict_GetItemString(                                         \
+                    descr->metadata, NPY_METADATA_DTSTR), NULL))))
+
+/*
+ * Deprecated as of NumPy 1.7, this kind of shortcut doesn't
+ * belong in the public API.
+ */
+#define NPY_AO PyArrayObject
+
+/*
+ * Deprecated as of NumPy 1.7, an all-lowercase macro doesn't
+ * belong in the public API.
+ */
+#define fortran fortran_
+
+/*
+ * Deprecated as of NumPy 1.7, as it is a namespace-polluting
+ * macro.
+ */
+#define FORTRAN_IF PyArray_FORTRAN_IF
+
+/* Deprecated as of NumPy 1.7, datetime64 uses c_metadata instead */
+#define NPY_METADATA_DTSTR "__timeunit__"
+
+/*
+ * Deprecated as of NumPy 1.7.
+ * The reasoning:
+ *  - These are for datetime, but there's no datetime "namespace".
+ *  - They just turn NPY_STR_<x> into "<x>", which is just
+ *    making something simple be indirected.
+ */
+#define NPY_STR_Y "Y"
+#define NPY_STR_M "M"
+#define NPY_STR_W "W"
+#define NPY_STR_D "D"
+#define NPY_STR_h "h"
+#define NPY_STR_m "m"
+#define NPY_STR_s "s"
+#define NPY_STR_ms "ms"
+#define NPY_STR_us "us"
+#define NPY_STR_ns "ns"
+#define NPY_STR_ps "ps"
+#define NPY_STR_fs "fs"
+#define NPY_STR_as "as"
+
+/*
+ * The macros in old_defines.h are Deprecated as of NumPy 1.7 and will be
+ * removed in the next major release.
+ */
+#include "old_defines.h"
+
+#endif  /* NUMPY_CORE_INCLUDE_NUMPY_NPY_1_7_DEPRECATED_API_H_ */

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/npy_3kcompat.h

@@ -0,0 +1,595 @@
+/*
+ * This is a convenience header file providing compatibility utilities
+ * for supporting different minor versions of Python 3.
+ * It was originally used to support the transition from Python 2,
+ * hence the "3k" naming.
+ *
+ * If you want to use this for your own projects, it's recommended to make a
+ * copy of it. Although the stuff below is unlikely to change, we don't provide
+ * strong backwards compatibility guarantees at the moment.
+ */
+
+#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_
+#define NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_
+
+#include <Python.h>
+#include <stdio.h>
+
+#ifndef NPY_PY3K
+#define NPY_PY3K 1
+#endif
+
+#include "numpy/npy_common.h"
+#include "numpy/ndarrayobject.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * PyInt -> PyLong
+ */
+
+
+/*
+ * This is a renamed copy of the Python non-limited API function _PyLong_AsInt. It is
+ * included here because it is missing from the PyPy API. It completes the PyLong_As*
+ * group of functions and can be useful in replacing PyInt_Check.
+ */
+static inline int
+Npy__PyLong_AsInt(PyObject *obj)
+{
+    int overflow;
+    long result = PyLong_AsLongAndOverflow(obj, &overflow);
+
+    /* INT_MAX and INT_MIN are defined in Python.h */
+    if (overflow || result > INT_MAX || result < INT_MIN) {
+        /* XXX: could be cute and give a different
+           message for overflow == -1 */
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C int");
+        return -1;
+    }
+    return (int)result;
+}
+
+
+#if defined(NPY_PY3K)
+/* Return True only if the long fits in a C long */
+static inline int PyInt_Check(PyObject *op) {
+    int overflow = 0;
+    if (!PyLong_Check(op)) {
+        return 0;
+    }
+    PyLong_AsLongAndOverflow(op, &overflow);
+    return (overflow == 0);
+}
+
+
+#define PyInt_FromLong PyLong_FromLong
+#define PyInt_AsLong PyLong_AsLong
+#define PyInt_AS_LONG PyLong_AsLong
+#define PyInt_AsSsize_t PyLong_AsSsize_t
+#define PyNumber_Int PyNumber_Long
+
+/* NOTE:
+ *
+ * Since the PyLong type is very different from the fixed-range PyInt,
+ * we don't define PyInt_Type -> PyLong_Type.
+ */
+#endif /* NPY_PY3K */
+
+/* Py3 changes PySlice_GetIndicesEx' first argument's type to PyObject* */
+#ifdef NPY_PY3K
+#  define NpySlice_GetIndicesEx PySlice_GetIndicesEx
+#else
+#  define NpySlice_GetIndicesEx(op, nop, start, end, step, slicelength) \
+    PySlice_GetIndicesEx((PySliceObject *)op, nop, start, end, step, slicelength)
+#endif
+
+#if PY_VERSION_HEX < 0x030900a4
+    /* Introduced in https://github.com/python/cpython/commit/d2ec81a8c99796b51fb8c49b77a7fe369863226f */
+    #define Py_SET_TYPE(obj, type) ((Py_TYPE(obj) = (type)), (void)0)
+    /* Introduced in https://github.com/python/cpython/commit/b10dc3e7a11fcdb97e285882eba6da92594f90f9 */
+    #define Py_SET_SIZE(obj, size) ((Py_SIZE(obj) = (size)), (void)0)
+    /* Introduced in https://github.com/python/cpython/commit/c86a11221df7e37da389f9c6ce6e47ea22dc44ff */
+    #define Py_SET_REFCNT(obj, refcnt) ((Py_REFCNT(obj) = (refcnt)), (void)0)
+#endif
+
+
+#define Npy_EnterRecursiveCall(x) Py_EnterRecursiveCall(x)
+
+/*
+ * PyString -> PyBytes
+ */
+
+#if defined(NPY_PY3K)
+
+#define PyString_Type PyBytes_Type
+#define PyString_Check PyBytes_Check
+#define PyStringObject PyBytesObject
+#define PyString_FromString PyBytes_FromString
+#define PyString_FromStringAndSize PyBytes_FromStringAndSize
+#define PyString_AS_STRING PyBytes_AS_STRING
+#define PyString_AsStringAndSize PyBytes_AsStringAndSize
+#define PyString_FromFormat PyBytes_FromFormat
+#define PyString_Concat PyBytes_Concat
+#define PyString_ConcatAndDel PyBytes_ConcatAndDel
+#define PyString_AsString PyBytes_AsString
+#define PyString_GET_SIZE PyBytes_GET_SIZE
+#define PyString_Size PyBytes_Size
+
+#define PyUString_Type PyUnicode_Type
+#define PyUString_Check PyUnicode_Check
+#define PyUStringObject PyUnicodeObject
+#define PyUString_FromString PyUnicode_FromString
+#define PyUString_FromStringAndSize PyUnicode_FromStringAndSize
+#define PyUString_FromFormat PyUnicode_FromFormat
+#define PyUString_Concat PyUnicode_Concat2
+#define PyUString_ConcatAndDel PyUnicode_ConcatAndDel
+#define PyUString_GET_SIZE PyUnicode_GET_SIZE
+#define PyUString_Size PyUnicode_Size
+#define PyUString_InternFromString PyUnicode_InternFromString
+#define PyUString_Format PyUnicode_Format
+
+#define PyBaseString_Check(obj) (PyUnicode_Check(obj))
+
+#else
+
+#define PyBytes_Type PyString_Type
+#define PyBytes_Check PyString_Check
+#define PyBytesObject PyStringObject
+#define PyBytes_FromString PyString_FromString
+#define PyBytes_FromStringAndSize PyString_FromStringAndSize
+#define PyBytes_AS_STRING PyString_AS_STRING
+#define PyBytes_AsStringAndSize PyString_AsStringAndSize
+#define PyBytes_FromFormat PyString_FromFormat
+#define PyBytes_Concat PyString_Concat
+#define PyBytes_ConcatAndDel PyString_ConcatAndDel
+#define PyBytes_AsString PyString_AsString
+#define PyBytes_GET_SIZE PyString_GET_SIZE
+#define PyBytes_Size PyString_Size
+
+#define PyUString_Type PyString_Type
+#define PyUString_Check PyString_Check
+#define PyUStringObject PyStringObject
+#define PyUString_FromString PyString_FromString
+#define PyUString_FromStringAndSize PyString_FromStringAndSize
+#define PyUString_FromFormat PyString_FromFormat
+#define PyUString_Concat PyString_Concat
+#define PyUString_ConcatAndDel PyString_ConcatAndDel
+#define PyUString_GET_SIZE PyString_GET_SIZE
+#define PyUString_Size PyString_Size
+#define PyUString_InternFromString PyString_InternFromString
+#define PyUString_Format PyString_Format
+
+#define PyBaseString_Check(obj) (PyBytes_Check(obj) || PyUnicode_Check(obj))
+
+#endif /* NPY_PY3K */
+
+/*
+ * Macros to protect CRT calls against instant termination when passed an
+ * invalid parameter (https://bugs.python.org/issue23524).
+ */
+#if defined _MSC_VER && _MSC_VER >= 1900
+
+#include <stdlib.h>
+
+extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler;
+#define NPY_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \
+    _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler);
+#define NPY_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); }
+
+#else
+
+#define NPY_BEGIN_SUPPRESS_IPH
+#define NPY_END_SUPPRESS_IPH
+
+#endif /* _MSC_VER >= 1900 */
+
+
+static inline void
+PyUnicode_ConcatAndDel(PyObject **left, PyObject *right)
+{
+    Py_SETREF(*left, PyUnicode_Concat(*left, right));
+    Py_DECREF(right);
+}
+
+static inline void
+PyUnicode_Concat2(PyObject **left, PyObject *right)
+{
+    Py_SETREF(*left, PyUnicode_Concat(*left, right));
+}
+
+/*
+ * PyFile_* compatibility
+ */
+
+/*
+ * Get a FILE* handle to the file represented by the Python object
+ */
+static inline FILE*
+npy_PyFile_Dup2(PyObject *file, char *mode, npy_off_t *orig_pos)
+{
+    int fd, fd2, unbuf;
+    Py_ssize_t fd2_tmp;
+    PyObject *ret, *os, *io, *io_raw;
+    npy_off_t pos;
+    FILE *handle;
+
+    /* For Python 2 PyFileObject, use PyFile_AsFile */
+#if !defined(NPY_PY3K)
+    if (PyFile_Check(file)) {
+        return PyFile_AsFile(file);
+    }
+#endif
+
+    /* Flush first to ensure things end up in the file in the correct order */
+    ret = PyObject_CallMethod(file, "flush", "");
+    if (ret == NULL) {
+        return NULL;
+    }
+    Py_DECREF(ret);
+    fd = PyObject_AsFileDescriptor(file);
+    if (fd == -1) {
+        return NULL;
+    }
+
+    /*
+     * The handle needs to be dup'd because we have to call fclose
+     * at the end
+     */
+    os = PyImport_ImportModule("os");
+    if (os == NULL) {
+        return NULL;
+    }
+    ret = PyObject_CallMethod(os, "dup", "i", fd);
+    Py_DECREF(os);
+    if (ret == NULL) {
+        return NULL;
+    }
+    fd2_tmp = PyNumber_AsSsize_t(ret, PyExc_IOError);
+    Py_DECREF(ret);
+    if (fd2_tmp == -1 && PyErr_Occurred()) {
+        return NULL;
+    }
+    if (fd2_tmp < INT_MIN || fd2_tmp > INT_MAX) {
+        PyErr_SetString(PyExc_IOError,
+                        "Getting an 'int' from os.dup() failed");
+        return NULL;
+    }
+    fd2 = (int)fd2_tmp;
+
+    /* Convert to FILE* handle */
+#ifdef _WIN32
+    NPY_BEGIN_SUPPRESS_IPH
+    handle = _fdopen(fd2, mode);
+    NPY_END_SUPPRESS_IPH
+#else
+    handle = fdopen(fd2, mode);
+#endif
+    if (handle == NULL) {
+        PyErr_SetString(PyExc_IOError,
+                        "Getting a FILE* from a Python file object via "
+                        "_fdopen failed. If you built NumPy, you probably "
+                        "linked with the wrong debug/release runtime");
+        return NULL;
+    }
+
+    /* Record the original raw file handle position */
+    *orig_pos = npy_ftell(handle);
+    if (*orig_pos == -1) {
+        /* The io module is needed to determine if buffering is used */
+        io = PyImport_ImportModule("io");
+        if (io == NULL) {
+            fclose(handle);
+            return NULL;
+        }
+        /* File object instances of RawIOBase are unbuffered */
+        io_raw = PyObject_GetAttrString(io, "RawIOBase");
+        Py_DECREF(io);
+        if (io_raw == NULL) {
+            fclose(handle);
+            return NULL;
+        }
+        unbuf = PyObject_IsInstance(file, io_raw);
+        Py_DECREF(io_raw);
+        if (unbuf == 1) {
+            /* Succeed if the IO is unbuffered */
+            return handle;
+        }
+        else {
+            PyErr_SetString(PyExc_IOError, "obtaining file position failed");
+            fclose(handle);
+            return NULL;
+        }
+    }
+
+    /* Seek raw handle to the Python-side position */
+    ret = PyObject_CallMethod(file, "tell", "");
+    if (ret == NULL) {
+        fclose(handle);
+        return NULL;
+    }
+    pos = PyLong_AsLongLong(ret);
+    Py_DECREF(ret);
+    if (PyErr_Occurred()) {
+        fclose(handle);
+        return NULL;
+    }
+    if (npy_fseek(handle, pos, SEEK_SET) == -1) {
+        PyErr_SetString(PyExc_IOError, "seeking file failed");
+        fclose(handle);
+        return NULL;
+    }
+    return handle;
+}
+
+/*
+ * Close the dup-ed file handle, and seek the Python one to the current position
+ */
+static inline int
+npy_PyFile_DupClose2(PyObject *file, FILE* handle, npy_off_t orig_pos)
+{
+    int fd, unbuf;
+    PyObject *ret, *io, *io_raw;
+    npy_off_t position;
+
+    /* For Python 2 PyFileObject, do nothing */
+#if !defined(NPY_PY3K)
+    if (PyFile_Check(file)) {
+        return 0;
+    }
+#endif
+
+    position = npy_ftell(handle);
+
+    /* Close the FILE* handle */
+    fclose(handle);
+
+    /*
+     * Restore original file handle position, in order to not confuse
+     * Python-side data structures
+     */
+    fd = PyObject_AsFileDescriptor(file);
+    if (fd == -1) {
+        return -1;
+    }
+
+    if (npy_lseek(fd, orig_pos, SEEK_SET) == -1) {
+
+        /* The io module is needed to determine if buffering is used */
+        io = PyImport_ImportModule("io");
+        if (io == NULL) {
+            return -1;
+        }
+        /* File object instances of RawIOBase are unbuffered */
+        io_raw = PyObject_GetAttrString(io, "RawIOBase");
+        Py_DECREF(io);
+        if (io_raw == NULL) {
+            return -1;
+        }
+        unbuf = PyObject_IsInstance(file, io_raw);
+        Py_DECREF(io_raw);
+        if (unbuf == 1) {
+            /* Succeed if the IO is unbuffered */
+            return 0;
+        }
+        else {
+            PyErr_SetString(PyExc_IOError, "seeking file failed");
+            return -1;
+        }
+    }
+
+    if (position == -1) {
+        PyErr_SetString(PyExc_IOError, "obtaining file position failed");
+        return -1;
+    }
+
+    /* Seek Python-side handle to the FILE* handle position */
+    ret = PyObject_CallMethod(file, "seek", NPY_OFF_T_PYFMT "i", position, 0);
+    if (ret == NULL) {
+        return -1;
+    }
+    Py_DECREF(ret);
+    return 0;
+}
+
+static inline int
+npy_PyFile_Check(PyObject *file)
+{
+    int fd;
+    /* For Python 2, check if it is a PyFileObject */
+#if !defined(NPY_PY3K)
+    if (PyFile_Check(file)) {
+        return 1;
+    }
+#endif
+    fd = PyObject_AsFileDescriptor(file);
+    if (fd == -1) {
+        PyErr_Clear();
+        return 0;
+    }
+    return 1;
+}
+
+static inline PyObject*
+npy_PyFile_OpenFile(PyObject *filename, const char *mode)
+{
+    PyObject *open;
+    open = PyDict_GetItemString(PyEval_GetBuiltins(), "open");
+    if (open == NULL) {
+        return NULL;
+    }
+    return PyObject_CallFunction(open, "Os", filename, mode);
+}
+
+static inline int
+npy_PyFile_CloseFile(PyObject *file)
+{
+    PyObject *ret;
+
+    ret = PyObject_CallMethod(file, "close", NULL);
+    if (ret == NULL) {
+        return -1;
+    }
+    Py_DECREF(ret);
+    return 0;
+}
+
+
+/* This is a copy of _PyErr_ChainExceptions
+ */
+static inline void
+npy_PyErr_ChainExceptions(PyObject *exc, PyObject *val, PyObject *tb)
+{
+    if (exc == NULL)
+        return;
+
+    if (PyErr_Occurred()) {
+        /* only py3 supports this anyway */
+        #ifdef NPY_PY3K
+            PyObject *exc2, *val2, *tb2;
+            PyErr_Fetch(&exc2, &val2, &tb2);
+            PyErr_NormalizeException(&exc, &val, &tb);
+            if (tb != NULL) {
+                PyException_SetTraceback(val, tb);
+                Py_DECREF(tb);
+            }
+            Py_DECREF(exc);
+            PyErr_NormalizeException(&exc2, &val2, &tb2);
+            PyException_SetContext(val2, val);
+            PyErr_Restore(exc2, val2, tb2);
+        #endif
+    }
+    else {
+        PyErr_Restore(exc, val, tb);
+    }
+}
+
+
+/* This is a copy of _PyErr_ChainExceptions, with:
+ *  - a minimal implementation for python 2
+ *  - __cause__ used instead of __context__
+ */
+static inline void
+npy_PyErr_ChainExceptionsCause(PyObject *exc, PyObject *val, PyObject *tb)
+{
+    if (exc == NULL)
+        return;
+
+    if (PyErr_Occurred()) {
+        /* only py3 supports this anyway */
+        #ifdef NPY_PY3K
+            PyObject *exc2, *val2, *tb2;
+            PyErr_Fetch(&exc2, &val2, &tb2);
+            PyErr_NormalizeException(&exc, &val, &tb);
+            if (tb != NULL) {
+                PyException_SetTraceback(val, tb);
+                Py_DECREF(tb);
+            }
+            Py_DECREF(exc);
+            PyErr_NormalizeException(&exc2, &val2, &tb2);
+            PyException_SetCause(val2, val);
+            PyErr_Restore(exc2, val2, tb2);
+        #endif
+    }
+    else {
+        PyErr_Restore(exc, val, tb);
+    }
+}
+
+/*
+ * PyObject_Cmp
+ */
+#if defined(NPY_PY3K)
+static inline int
+PyObject_Cmp(PyObject *i1, PyObject *i2, int *cmp)
+{
+    int v;
+    v = PyObject_RichCompareBool(i1, i2, Py_LT);
+    if (v == 1) {
+        *cmp = -1;
+        return 1;
+    }
+    else if (v == -1) {
+        return -1;
+    }
+
+    v = PyObject_RichCompareBool(i1, i2, Py_GT);
+    if (v == 1) {
+        *cmp = 1;
+        return 1;
+    }
+    else if (v == -1) {
+        return -1;
+    }
+
+    v = PyObject_RichCompareBool(i1, i2, Py_EQ);
+    if (v == 1) {
+        *cmp = 0;
+        return 1;
+    }
+    else {
+        *cmp = 0;
+        return -1;
+    }
+}
+#endif
+
+/*
+ * PyCObject functions adapted to PyCapsules.
+ *
+ * The main job here is to get rid of the improved error handling
+ * of PyCapsules. It's a shame...
+ */
+static inline PyObject *
+NpyCapsule_FromVoidPtr(void *ptr, void (*dtor)(PyObject *))
+{
+    PyObject *ret = PyCapsule_New(ptr, NULL, dtor);
+    if (ret == NULL) {
+        PyErr_Clear();
+    }
+    return ret;
+}
+
+static inline PyObject *
+NpyCapsule_FromVoidPtrAndDesc(void *ptr, void* context, void (*dtor)(PyObject *))
+{
+    PyObject *ret = NpyCapsule_FromVoidPtr(ptr, dtor);
+    if (ret != NULL && PyCapsule_SetContext(ret, context) != 0) {
+        PyErr_Clear();
+        Py_DECREF(ret);
+        ret = NULL;
+    }
+    return ret;
+}
+
+static inline void *
+NpyCapsule_AsVoidPtr(PyObject *obj)
+{
+    void *ret = PyCapsule_GetPointer(obj, NULL);
+    if (ret == NULL) {
+        PyErr_Clear();
+    }
+    return ret;
+}
+
+static inline void *
+NpyCapsule_GetDesc(PyObject *obj)
+{
+    return PyCapsule_GetContext(obj);
+}
+
+static inline int
+NpyCapsule_Check(PyObject *ptr)
+{
+    return PyCapsule_CheckExact(ptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  /* NUMPY_CORE_INCLUDE_NUMPY_NPY_3KCOMPAT_H_ */

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/npy_interrupt.h

@@ -0,0 +1,56 @@
+/*
+ * This API is only provided because it is part of publicly exported
+ * headers. Its use is considered DEPRECATED, and it will be removed
+ * eventually.
+ * (This includes the _PyArray_SigintHandler and _PyArray_GetSigintBuf
+ * functions which are however, public API, and not headers.)
+ *
+ * Instead of using these non-threadsafe macros consider periodically
+ * querying `PyErr_CheckSignals()` or `PyOS_InterruptOccurred()` will work.
+ * Both of these require holding the GIL, although cpython could add a
+ * version of `PyOS_InterruptOccurred()` which does not. Such a version
+ * actually exists as private API in Python 3.10, and backported to 3.9 and 3.8,
+ * see also https://bugs.python.org/issue41037 and
+ * https://github.com/python/cpython/pull/20599).
+ */
+
+#ifndef NUMPY_CORE_INCLUDE_NUMPY_NPY_INTERRUPT_H_
+#define NUMPY_CORE_INCLUDE_NUMPY_NPY_INTERRUPT_H_
+
+#ifndef NPY_NO_SIGNAL
+
+#include <setjmp.h>
+#include <signal.h>
+
+#ifndef sigsetjmp
+
+#define NPY_SIGSETJMP(arg1, arg2) setjmp(arg1)
+#define NPY_SIGLONGJMP(arg1, arg2) longjmp(arg1, arg2)
+#define NPY_SIGJMP_BUF jmp_buf
+
+#else
+
+#define NPY_SIGSETJMP(arg1, arg2) sigsetjmp(arg1, arg2)
+#define NPY_SIGLONGJMP(arg1, arg2) siglongjmp(arg1, arg2)
+#define NPY_SIGJMP_BUF sigjmp_buf
+
+#endif
+
+#    define NPY_SIGINT_ON {                                             \
+                   PyOS_sighandler_t _npy_sig_save;                     \
+                   _npy_sig_save = PyOS_setsig(SIGINT, _PyArray_SigintHandler); \
+                   if (NPY_SIGSETJMP(*((NPY_SIGJMP_BUF *)_PyArray_GetSigintBuf()), \
+                                 1) == 0) {                             \
+
+#    define NPY_SIGINT_OFF }                                      \
+        PyOS_setsig(SIGINT, _npy_sig_save);                       \
+        }
+
+#else  /* NPY_NO_SIGNAL  */
+
+#define NPY_SIGINT_ON
+#define NPY_SIGINT_OFF
+
+#endif  /* HAVE_SIGSETJMP */
+
+#endif  /* NUMPY_CORE_INCLUDE_NUMPY_NPY_INTERRUPT_H_ */

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/random/LICENSE.txt

@@ -0,0 +1,21 @@
+  zlib License
+  ------------
+
+  Copyright (C) 2010 - 2019 ridiculous_fish, <[email protected]>
+  Copyright (C) 2016 - 2019 Kim Walisch, <[email protected]>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/random/bitgen.h

@@ -0,0 +1,20 @@
+#ifndef NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_
+#define NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_
+
+#pragma once
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+/* Must match the declaration in numpy/random/<any>.pxd */
+
+typedef struct bitgen {
+  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);
+} bitgen_t;
+
+
+#endif  /* NUMPY_CORE_INCLUDE_NUMPY_RANDOM_BITGEN_H_ */

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/random/distributions.h

@@ -0,0 +1,209 @@
+#ifndef NUMPY_CORE_INCLUDE_NUMPY_RANDOM_DISTRIBUTIONS_H_
+#define NUMPY_CORE_INCLUDE_NUMPY_RANDOM_DISTRIBUTIONS_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <Python.h>
+#include "numpy/npy_common.h"
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "numpy/npy_math.h"
+#include "numpy/random/bitgen.h"
+
+/*
+ * RAND_INT_TYPE is used to share integer generators with RandomState which
+ * used long in place of int64_t. If changing a distribution that uses
+ * RAND_INT_TYPE, then the original unmodified copy must be retained for
+ * use in RandomState by copying to the legacy distributions source file.
+ */
+#ifdef NP_RANDOM_LEGACY
+#define RAND_INT_TYPE long
+#define RAND_INT_MAX LONG_MAX
+#else
+#define RAND_INT_TYPE int64_t
+#define RAND_INT_MAX INT64_MAX
+#endif
+
+#ifdef _MSC_VER
+#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;
+  RAND_INT_TYPE nsave;
+  double r;
+  double q;
+  double fm;
+  RAND_INT_TYPE m;
+  double p1;
+  double xm;
+  double xl;
+  double xr;
+  double c;
+  double laml;
+  double lamr;
+  double p2;
+  double p3;
+  double p4;
+} binomial_t;
+
+DECLDIR float random_standard_uniform_f(bitgen_t *bitgen_state);
+DECLDIR double random_standard_uniform(bitgen_t *bitgen_state);
+DECLDIR void random_standard_uniform_fill(bitgen_t *, npy_intp, double *);
+DECLDIR void random_standard_uniform_fill_f(bitgen_t *, npy_intp, float *);
+
+DECLDIR int64_t random_positive_int64(bitgen_t *bitgen_state);
+DECLDIR int32_t random_positive_int32(bitgen_t *bitgen_state);
+DECLDIR int64_t random_positive_int(bitgen_t *bitgen_state);
+DECLDIR uint64_t random_uint(bitgen_t *bitgen_state);
+
+DECLDIR double random_standard_exponential(bitgen_t *bitgen_state);
+DECLDIR float random_standard_exponential_f(bitgen_t *bitgen_state);
+DECLDIR void random_standard_exponential_fill(bitgen_t *, npy_intp, double *);
+DECLDIR void random_standard_exponential_fill_f(bitgen_t *, npy_intp, float *);
+DECLDIR void random_standard_exponential_inv_fill(bitgen_t *, npy_intp, double *);
+DECLDIR void random_standard_exponential_inv_fill_f(bitgen_t *, npy_intp, float *);
+
+DECLDIR double random_standard_normal(bitgen_t *bitgen_state);
+DECLDIR float random_standard_normal_f(bitgen_t *bitgen_state);
+DECLDIR void random_standard_normal_fill(bitgen_t *, npy_intp, double *);
+DECLDIR void random_standard_normal_fill_f(bitgen_t *, npy_intp, float *);
+DECLDIR double random_standard_gamma(bitgen_t *bitgen_state, double shape);
+DECLDIR float random_standard_gamma_f(bitgen_t *bitgen_state, float shape);
+
+DECLDIR double random_normal(bitgen_t *bitgen_state, double loc, double scale);
+
+DECLDIR double random_gamma(bitgen_t *bitgen_state, double shape, double scale);
+DECLDIR float random_gamma_f(bitgen_t *bitgen_state, float shape, float scale);
+
+DECLDIR double random_exponential(bitgen_t *bitgen_state, double scale);
+DECLDIR double random_uniform(bitgen_t *bitgen_state, double lower, double range);
+DECLDIR double random_beta(bitgen_t *bitgen_state, double a, double b);
+DECLDIR double random_chisquare(bitgen_t *bitgen_state, double df);
+DECLDIR double random_f(bitgen_t *bitgen_state, double dfnum, double dfden);
+DECLDIR double random_standard_cauchy(bitgen_t *bitgen_state);
+DECLDIR double random_pareto(bitgen_t *bitgen_state, double a);
+DECLDIR double random_weibull(bitgen_t *bitgen_state, double a);
+DECLDIR double random_power(bitgen_t *bitgen_state, double a);
+DECLDIR double random_laplace(bitgen_t *bitgen_state, double loc, double scale);
+DECLDIR double random_gumbel(bitgen_t *bitgen_state, double loc, double scale);
+DECLDIR double random_logistic(bitgen_t *bitgen_state, double loc, double scale);
+DECLDIR double random_lognormal(bitgen_t *bitgen_state, double mean, double sigma);
+DECLDIR double random_rayleigh(bitgen_t *bitgen_state, double mode);
+DECLDIR double random_standard_t(bitgen_t *bitgen_state, double df);
+DECLDIR double random_noncentral_chisquare(bitgen_t *bitgen_state, double df,
+                                           double nonc);
+DECLDIR double random_noncentral_f(bitgen_t *bitgen_state, double dfnum,
+                                   double dfden, double nonc);
+DECLDIR double random_wald(bitgen_t *bitgen_state, double mean, double scale);
+DECLDIR double random_vonmises(bitgen_t *bitgen_state, double mu, double kappa);
+DECLDIR double random_triangular(bitgen_t *bitgen_state, double left, double mode,
+                                 double right);
+
+DECLDIR RAND_INT_TYPE random_poisson(bitgen_t *bitgen_state, double lam);
+DECLDIR RAND_INT_TYPE random_negative_binomial(bitgen_t *bitgen_state, double n,
+                                 double p);
+
+DECLDIR int64_t random_binomial(bitgen_t *bitgen_state, double p,
+                                int64_t n, binomial_t *binomial);
+
+DECLDIR int64_t random_logseries(bitgen_t *bitgen_state, double p);
+DECLDIR int64_t random_geometric(bitgen_t *bitgen_state, double p);
+DECLDIR RAND_INT_TYPE random_geometric_search(bitgen_t *bitgen_state, double p);
+DECLDIR RAND_INT_TYPE random_zipf(bitgen_t *bitgen_state, double a);
+DECLDIR int64_t random_hypergeometric(bitgen_t *bitgen_state,
+                                      int64_t good, int64_t bad, int64_t sample);
+DECLDIR uint64_t random_interval(bitgen_t *bitgen_state, uint64_t max);
+
+/* Generate random uint64 numbers in closed interval [off, off + rng]. */
+DECLDIR uint64_t random_bounded_uint64(bitgen_t *bitgen_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(bitgen_t *bitgen_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(bitgen_t *bitgen_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(bitgen_t *bitgen_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(bitgen_t *bitgen_state, npy_bool off,
+                                              npy_bool rng, npy_bool mask,
+                                              bool use_masked, int *bcnt,
+                                              uint32_t *buf);
+
+DECLDIR void random_bounded_uint64_fill(bitgen_t *bitgen_state, uint64_t off,
+                                        uint64_t rng, npy_intp cnt,
+                                        bool use_masked, uint64_t *out);
+DECLDIR void random_bounded_uint32_fill(bitgen_t *bitgen_state, uint32_t off,
+                                        uint32_t rng, npy_intp cnt,
+                                        bool use_masked, uint32_t *out);
+DECLDIR void random_bounded_uint16_fill(bitgen_t *bitgen_state, uint16_t off,
+                                        uint16_t rng, npy_intp cnt,
+                                        bool use_masked, uint16_t *out);
+DECLDIR void random_bounded_uint8_fill(bitgen_t *bitgen_state, uint8_t off,
+                                       uint8_t rng, npy_intp cnt,
+                                       bool use_masked, uint8_t *out);
+DECLDIR void random_bounded_bool_fill(bitgen_t *bitgen_state, npy_bool off,
+                                      npy_bool rng, npy_intp cnt,
+                                      bool use_masked, npy_bool *out);
+
+DECLDIR void random_multinomial(bitgen_t *bitgen_state, RAND_INT_TYPE n, RAND_INT_TYPE *mnix,
+                                double *pix, npy_intp d, binomial_t *binomial);
+
+/* multivariate hypergeometric, "count" method */
+DECLDIR int random_multivariate_hypergeometric_count(bitgen_t *bitgen_state,
+                              int64_t total,
+                              size_t num_colors, int64_t *colors,
+                              int64_t nsample,
+                              size_t num_variates, int64_t *variates);
+
+/* multivariate hypergeometric, "marginals" method */
+DECLDIR void random_multivariate_hypergeometric_marginals(bitgen_t *bitgen_state,
+                                   int64_t total,
+                                   size_t num_colors, int64_t *colors,
+                                   int64_t nsample,
+                                   size_t num_variates, int64_t *variates);
+
+/* Common to legacy-distributions.c and distributions.c but not exported */
+
+RAND_INT_TYPE random_binomial_btpe(bitgen_t *bitgen_state,
+                                   RAND_INT_TYPE n,
+                                   double p,
+                                   binomial_t *binomial);
+RAND_INT_TYPE random_binomial_inversion(bitgen_t *bitgen_state,
+                                        RAND_INT_TYPE n,
+                                        double p,
+                                        binomial_t *binomial);
+double random_loggam(double x);
+static inline double next_double(bitgen_t *bitgen_state) {
+    return bitgen_state->next_double(bitgen_state->state);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* NUMPY_CORE_INCLUDE_NUMPY_RANDOM_DISTRIBUTIONS_H_ */

env-llmeval/lib/python3.10/site-packages/numpy/core/include/numpy/random/libdivide.h

@@ -0,0 +1,2079 @@
+// libdivide.h - Optimized integer division
+// https://libdivide.com
+//
+// Copyright (C) 2010 - 2019 ridiculous_fish, <[email protected]>
+// Copyright (C) 2016 - 2019 Kim Walisch, <[email protected]>
+//
+// libdivide is dual-licensed under the Boost or zlib licenses.
+// You may use libdivide under the terms of either of these.
+// See LICENSE.txt for more details.
+
+#ifndef NUMPY_CORE_INCLUDE_NUMPY_LIBDIVIDE_LIBDIVIDE_H_
+#define NUMPY_CORE_INCLUDE_NUMPY_LIBDIVIDE_LIBDIVIDE_H_
+
+#define LIBDIVIDE_VERSION "3.0"
+#define LIBDIVIDE_VERSION_MAJOR 3
+#define LIBDIVIDE_VERSION_MINOR 0
+
+#include <stdint.h>
+
+#if defined(__cplusplus)
+    #include <cstdlib>
+    #include <cstdio>
+    #include <type_traits>
+#else
+    #include <stdlib.h>
+    #include <stdio.h>
+#endif
+
+#if defined(LIBDIVIDE_AVX512)
+    #include <immintrin.h>
+#elif defined(LIBDIVIDE_AVX2)
+    #include <immintrin.h>
+#elif defined(LIBDIVIDE_SSE2)
+    #include <emmintrin.h>
+#endif
+
+#if defined(_MSC_VER)
+    #include <intrin.h>
+    // disable warning C4146: unary minus operator applied
+    // to unsigned type, result still unsigned
+    #pragma warning(disable: 4146)
+    #define LIBDIVIDE_VC
+#endif
+
+#if !defined(__has_builtin)
+    #define __has_builtin(x) 0
+#endif
+
+#if defined(__SIZEOF_INT128__)
+    #define HAS_INT128_T
+    // clang-cl on Windows does not yet support 128-bit division
+    #if !(defined(__clang__) && defined(LIBDIVIDE_VC))
+        #define HAS_INT128_DIV
+    #endif
+#endif
+
+#if defined(__x86_64__) || defined(_M_X64)
+    #define LIBDIVIDE_X86_64
+#endif
+
+#if defined(__i386__)
+    #define LIBDIVIDE_i386
+#endif
+
+#if defined(__GNUC__) || defined(__clang__)
+    #define LIBDIVIDE_GCC_STYLE_ASM
+#endif
+
+#if defined(__cplusplus) || defined(LIBDIVIDE_VC)
+    #define LIBDIVIDE_FUNCTION __FUNCTION__
+#else
+    #define LIBDIVIDE_FUNCTION __func__
+#endif
+
+#define LIBDIVIDE_ERROR(msg) \
+    do { \
+        fprintf(stderr, "libdivide.h:%d: %s(): Error: %s\n", \
+            __LINE__, LIBDIVIDE_FUNCTION, msg); \
+        abort(); \
+    } while (0)
+
+#if defined(LIBDIVIDE_ASSERTIONS_ON)
+    #define LIBDIVIDE_ASSERT(x) \
+        do { \
+            if (!(x)) { \
+                fprintf(stderr, "libdivide.h:%d: %s(): Assertion failed: %s\n", \
+                    __LINE__, LIBDIVIDE_FUNCTION, #x); \
+                abort(); \
+            } \
+        } while (0)
+#else
+    #define LIBDIVIDE_ASSERT(x)
+#endif
+
+#ifdef __cplusplus
+namespace libdivide {
+#endif
+
+// pack divider structs to prevent compilers from padding.
+// This reduces memory usage by up to 43% when using a large
+// array of libdivide dividers and improves performance
+// by up to 10% because of reduced memory bandwidth.
+#pragma pack(push, 1)
+
+struct libdivide_u32_t {
+    uint32_t magic;
+    uint8_t more;
+};
+
+struct libdivide_s32_t {
+    int32_t magic;
+    uint8_t more;
+};
+
+struct libdivide_u64_t {
+    uint64_t magic;
+    uint8_t more;
+};
+
+struct libdivide_s64_t {
+    int64_t magic;
+    uint8_t more;
+};
+
+struct libdivide_u32_branchfree_t {
+    uint32_t magic;
+    uint8_t more;
+};
+
+struct libdivide_s32_branchfree_t {
+    int32_t magic;
+    uint8_t more;
+};
+
+struct libdivide_u64_branchfree_t {
+    uint64_t magic;
+    uint8_t more;
+};
+
+struct libdivide_s64_branchfree_t {
+    int64_t magic;
+    uint8_t more;
+};
+
+#pragma pack(pop)
+
+// Explanation of the "more" field:
+//
+// * Bits 0-5 is the shift value (for shift path or mult path).
+// * Bit 6 is the add indicator for mult path.
+// * Bit 7 is set if the divisor is negative. We use bit 7 as the negative
+//   divisor indicator so that we can efficiently use sign extension to
+//   create a bitmask with all bits set to 1 (if the divisor is negative)
+//   or 0 (if the divisor is positive).
+//
+// u32: [0-4] shift value
+//      [5] ignored
+//      [6] add indicator
+//      magic number of 0 indicates shift path
+//
+// s32: [0-4] shift value
+//      [5] ignored
+//      [6] add indicator
+//      [7] indicates negative divisor
+//      magic number of 0 indicates shift path
+//
+// u64: [0-5] shift value
+//      [6] add indicator
+//      magic number of 0 indicates shift path
+//
+// s64: [0-5] shift value
+//      [6] add indicator
+//      [7] indicates negative divisor
+//      magic number of 0 indicates shift path
+//
+// In s32 and s64 branchfree modes, the magic number is negated according to
+// whether the divisor is negated. In branchfree strategy, it is not negated.
+
+enum {
+    LIBDIVIDE_32_SHIFT_MASK = 0x1F,
+    LIBDIVIDE_64_SHIFT_MASK = 0x3F,
+    LIBDIVIDE_ADD_MARKER = 0x40,
+    LIBDIVIDE_NEGATIVE_DIVISOR = 0x80
+};
+
+static inline struct libdivide_s32_t libdivide_s32_gen(int32_t d);
+static inline struct libdivide_u32_t libdivide_u32_gen(uint32_t d);
+static inline struct libdivide_s64_t libdivide_s64_gen(int64_t d);
+static inline struct libdivide_u64_t libdivide_u64_gen(uint64_t d);
+
+static inline struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d);
+static inline struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d);
+static inline struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d);
+static inline struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d);
+
+static inline int32_t  libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom);
+static inline uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom);
+static inline int64_t  libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom);
+static inline uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom);
+
+static inline int32_t  libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom);
+static inline uint32_t libdivide_u32_branchfree_do(uint32_t numer, const struct libdivide_u32_branchfree_t *denom);
+static inline int64_t  libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom);
+static inline uint64_t libdivide_u64_branchfree_do(uint64_t numer, const struct libdivide_u64_branchfree_t *denom);
+
+static inline int32_t  libdivide_s32_recover(const struct libdivide_s32_t *denom);
+static inline uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom);
+static inline int64_t  libdivide_s64_recover(const struct libdivide_s64_t *denom);
+static inline uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom);
+
+static inline int32_t  libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom);
+static inline uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom);
+static inline int64_t  libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom);
+static inline uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom);
+
+//////// Internal Utility Functions
+
+static inline uint32_t libdivide_mullhi_u32(uint32_t x, uint32_t y) {
+    uint64_t xl = x, yl = y;
+    uint64_t rl = xl * yl;
+    return (uint32_t)(rl >> 32);
+}
+
+static inline int32_t libdivide_mullhi_s32(int32_t x, int32_t y) {
+    int64_t xl = x, yl = y;
+    int64_t rl = xl * yl;
+    // needs to be arithmetic shift
+    return (int32_t)(rl >> 32);
+}
+
+static inline uint64_t libdivide_mullhi_u64(uint64_t x, uint64_t y) {
+#if defined(LIBDIVIDE_VC) && \
+    defined(LIBDIVIDE_X86_64)
+    return __umulh(x, y);
+#elif defined(HAS_INT128_T)
+    __uint128_t xl = x, yl = y;
+    __uint128_t rl = xl * yl;
+    return (uint64_t)(rl >> 64);
+#else
+    // full 128 bits are x0 * y0 + (x0 * y1 << 32) + (x1 * y0 << 32) + (x1 * y1 << 64)
+    uint32_t mask = 0xFFFFFFFF;
+    uint32_t x0 = (uint32_t)(x & mask);
+    uint32_t x1 = (uint32_t)(x >> 32);
+    uint32_t y0 = (uint32_t)(y & mask);
+    uint32_t y1 = (uint32_t)(y >> 32);
+    uint32_t x0y0_hi = libdivide_mullhi_u32(x0, y0);
+    uint64_t x0y1 = x0 * (uint64_t)y1;
+    uint64_t x1y0 = x1 * (uint64_t)y0;
+    uint64_t x1y1 = x1 * (uint64_t)y1;
+    uint64_t temp = x1y0 + x0y0_hi;
+    uint64_t temp_lo = temp & mask;
+    uint64_t temp_hi = temp >> 32;
+
+    return x1y1 + temp_hi + ((temp_lo + x0y1) >> 32);
+#endif
+}
+
+static inline int64_t libdivide_mullhi_s64(int64_t x, int64_t y) {
+#if defined(LIBDIVIDE_VC) && \
+    defined(LIBDIVIDE_X86_64)
+    return __mulh(x, y);
+#elif defined(HAS_INT128_T)
+    __int128_t xl = x, yl = y;
+    __int128_t rl = xl * yl;
+    return (int64_t)(rl >> 64);
+#else
+    // full 128 bits are x0 * y0 + (x0 * y1 << 32) + (x1 * y0 << 32) + (x1 * y1 << 64)
+    uint32_t mask = 0xFFFFFFFF;
+    uint32_t x0 = (uint32_t)(x & mask);
+    uint32_t y0 = (uint32_t)(y & mask);
+    int32_t x1 = (int32_t)(x >> 32);
+    int32_t y1 = (int32_t)(y >> 32);
+    uint32_t x0y0_hi = libdivide_mullhi_u32(x0, y0);
+    int64_t t = x1 * (int64_t)y0 + x0y0_hi;
+    int64_t w1 = x0 * (int64_t)y1 + (t & mask);
+
+    return x1 * (int64_t)y1 + (t >> 32) + (w1 >> 32);
+#endif
+}
+
+static inline int32_t libdivide_count_leading_zeros32(uint32_t val) {
+#if defined(__GNUC__) || \
+    __has_builtin(__builtin_clz)
+    // Fast way to count leading zeros
+    return __builtin_clz(val);
+#elif defined(LIBDIVIDE_VC)
+    unsigned long result;
+    if (_BitScanReverse(&result, val)) {
+        return 31 - result;
+    }
+    return 0;
+#else
+    if (val == 0)
+        return 32;
+    int32_t result = 8;
+    uint32_t hi = 0xFFU << 24;
+    while ((val & hi) == 0) {
+        hi >>= 8;
+        result += 8;
+    }
+    while (val & hi) {
+        result -= 1;
+        hi <<= 1;
+    }
+    return result;
+#endif
+}
+
+static inline int32_t libdivide_count_leading_zeros64(uint64_t val) {
+#if defined(__GNUC__) || \
+    __has_builtin(__builtin_clzll)
+    // Fast way to count leading zeros
+    return __builtin_clzll(val);
+#elif defined(LIBDIVIDE_VC) && defined(_WIN64)
+    unsigned long result;
+    if (_BitScanReverse64(&result, val)) {
+        return 63 - result;
+    }
+    return 0;
+#else
+    uint32_t hi = val >> 32;
+    uint32_t lo = val & 0xFFFFFFFF;
+    if (hi != 0) return libdivide_count_leading_zeros32(hi);
+    return 32 + libdivide_count_leading_zeros32(lo);
+#endif
+}
+
+// libdivide_64_div_32_to_32: divides a 64-bit uint {u1, u0} by a 32-bit
+// uint {v}. The result must fit in 32 bits.
+// Returns the quotient directly and the remainder in *r
+static inline uint32_t libdivide_64_div_32_to_32(uint32_t u1, uint32_t u0, uint32_t v, uint32_t *r) {
+#if (defined(LIBDIVIDE_i386) || defined(LIBDIVIDE_X86_64)) && \
+     defined(LIBDIVIDE_GCC_STYLE_ASM)
+    uint32_t result;
+    __asm__("divl %[v]"
+            : "=a"(result), "=d"(*r)
+            : [v] "r"(v), "a"(u0), "d"(u1)
+            );
+    return result;
+#else
+    uint64_t n = ((uint64_t)u1 << 32) | u0;
+    uint32_t result = (uint32_t)(n / v);
+    *r = (uint32_t)(n - result * (uint64_t)v);
+    return result;
+#endif
+}
+
+// libdivide_128_div_64_to_64: divides a 128-bit uint {u1, u0} by a 64-bit
+// uint {v}. The result must fit in 64 bits.
+// Returns the quotient directly and the remainder in *r
+static uint64_t libdivide_128_div_64_to_64(uint64_t u1, uint64_t u0, uint64_t v, uint64_t *r) {
+#if defined(LIBDIVIDE_X86_64) && \
+    defined(LIBDIVIDE_GCC_STYLE_ASM)
+    uint64_t result;
+    __asm__("divq %[v]"
+            : "=a"(result), "=d"(*r)
+            : [v] "r"(v), "a"(u0), "d"(u1)
+            );
+    return result;
+#elif defined(HAS_INT128_T) && \
+      defined(HAS_INT128_DIV)
+    __uint128_t n = ((__uint128_t)u1 << 64) | u0;
+    uint64_t result = (uint64_t)(n / v);
+    *r = (uint64_t)(n - result * (__uint128_t)v);
+    return result;
+#else
+    // Code taken from Hacker's Delight:
+    // http://www.hackersdelight.org/HDcode/divlu.c.
+    // License permits inclusion here per:
+    // http://www.hackersdelight.org/permissions.htm
+
+    const uint64_t b = (1ULL << 32); // Number base (32 bits)
+    uint64_t un1, un0; // Norm. dividend LSD's
+    uint64_t vn1, vn0; // Norm. divisor digits
+    uint64_t q1, q0; // Quotient digits
+    uint64_t un64, un21, un10; // Dividend digit pairs
+    uint64_t rhat; // A remainder
+    int32_t s; // Shift amount for norm
+
+    // If overflow, set rem. to an impossible value,
+    // and return the largest possible quotient
+    if (u1 >= v) {
+        *r = (uint64_t) -1;
+        return (uint64_t) -1;
+    }
+
+    // count leading zeros
+    s = libdivide_count_leading_zeros64(v);
+    if (s > 0) {
+        // Normalize divisor
+        v = v << s;
+        un64 = (u1 << s) | (u0 >> (64 - s));
+        un10 = u0 << s; // Shift dividend left
+    } else {
+        // Avoid undefined behavior of (u0 >> 64).
+        // The behavior is undefined if the right operand is
+        // negative, or greater than or equal to the length
+        // in bits of the promoted left operand.
+        un64 = u1;
+        un10 = u0;
+    }
+
+    // Break divisor up into two 32-bit digits
+    vn1 = v >> 32;
+    vn0 = v & 0xFFFFFFFF;
+
+    // Break right half of dividend into two digits
+    un1 = un10 >> 32;
+    un0 = un10 & 0xFFFFFFFF;
+
+    // Compute the first quotient digit, q1
+    q1 = un64 / vn1;
+    rhat = un64 - q1 * vn1;
+
+    while (q1 >= b || q1 * vn0 > b * rhat + un1) {
+        q1 = q1 - 1;
+        rhat = rhat + vn1;
+        if (rhat >= b)
+            break;
+    }
+
+     // Multiply and subtract
+    un21 = un64 * b + un1 - q1 * v;
+
+    // Compute the second quotient digit
+    q0 = un21 / vn1;
+    rhat = un21 - q0 * vn1;
+
+    while (q0 >= b || q0 * vn0 > b * rhat + un0) {
+        q0 = q0 - 1;
+        rhat = rhat + vn1;
+        if (rhat >= b)
+            break;
+    }
+
+    *r = (un21 * b + un0 - q0 * v) >> s;
+    return q1 * b + q0;
+#endif
+}
+
+// Bitshift a u128 in place, left (signed_shift > 0) or right (signed_shift < 0)
+static inline void libdivide_u128_shift(uint64_t *u1, uint64_t *u0, int32_t signed_shift) {
+    if (signed_shift > 0) {
+        uint32_t shift = signed_shift;
+        *u1 <<= shift;
+        *u1 |= *u0 >> (64 - shift);
+        *u0 <<= shift;
+    }
+    else if (signed_shift < 0) {
+        uint32_t shift = -signed_shift;
+        *u0 >>= shift;
+        *u0 |= *u1 << (64 - shift);
+        *u1 >>= shift;
+    }
+}
+
+// Computes a 128 / 128 -> 64 bit division, with a 128 bit remainder.
+static uint64_t libdivide_128_div_128_to_64(uint64_t u_hi, uint64_t u_lo, uint64_t v_hi, uint64_t v_lo, uint64_t *r_hi, uint64_t *r_lo) {
+#if defined(HAS_INT128_T) && \
+    defined(HAS_INT128_DIV)
+    __uint128_t ufull = u_hi;
+    __uint128_t vfull = v_hi;
+    ufull = (ufull << 64) | u_lo;
+    vfull = (vfull << 64) | v_lo;
+    uint64_t res = (uint64_t)(ufull / vfull);
+    __uint128_t remainder = ufull - (vfull * res);
+    *r_lo = (uint64_t)remainder;
+    *r_hi = (uint64_t)(remainder >> 64);
+    return res;
+#else
+    // Adapted from "Unsigned Doubleword Division" in Hacker's Delight
+    // We want to compute u / v
+    typedef struct { uint64_t hi; uint64_t lo; } u128_t;
+    u128_t u = {u_hi, u_lo};
+    u128_t v = {v_hi, v_lo};
+
+    if (v.hi == 0) {
+        // divisor v is a 64 bit value, so we just need one 128/64 division
+        // Note that we are simpler than Hacker's Delight here, because we know
+        // the quotient fits in 64 bits whereas Hacker's Delight demands a full
+        // 128 bit quotient
+        *r_hi = 0;
+        return libdivide_128_div_64_to_64(u.hi, u.lo, v.lo, r_lo);
+    }
+    // Here v >= 2**64
+    // We know that v.hi != 0, so count leading zeros is OK
+    // We have 0 <= n <= 63
+    uint32_t n = libdivide_count_leading_zeros64(v.hi);
+
+    // Normalize the divisor so its MSB is 1
+    u128_t v1t = v;
+    libdivide_u128_shift(&v1t.hi, &v1t.lo, n);
+    uint64_t v1 = v1t.hi; // i.e. v1 = v1t >> 64
+
+    // To ensure no overflow
+    u128_t u1 = u;
+    libdivide_u128_shift(&u1.hi, &u1.lo, -1);
+
+    // Get quotient from divide unsigned insn.
+    uint64_t rem_ignored;
+    uint64_t q1 = libdivide_128_div_64_to_64(u1.hi, u1.lo, v1, &rem_ignored);
+
+    // Undo normalization and division of u by 2.
+    u128_t q0 = {0, q1};
+    libdivide_u128_shift(&q0.hi, &q0.lo, n);
+    libdivide_u128_shift(&q0.hi, &q0.lo, -63);
+
+    // Make q0 correct or too small by 1
+    // Equivalent to `if (q0 != 0) q0 = q0 - 1;`
+    if (q0.hi != 0 || q0.lo != 0) {
+        q0.hi -= (q0.lo == 0); // borrow
+        q0.lo -= 1;
+    }
+
+    // Now q0 is correct.
+    // Compute q0 * v as q0v
+    // = (q0.hi << 64 + q0.lo) * (v.hi << 64 + v.lo)
+    // = (q0.hi * v.hi << 128) + (q0.hi * v.lo << 64) +
+    //   (q0.lo * v.hi <<  64) + q0.lo * v.lo)
+    // Each term is 128 bit
+    // High half of full product (upper 128 bits!) are dropped
+    u128_t q0v = {0, 0};
+    q0v.hi = q0.hi*v.lo + q0.lo*v.hi + libdivide_mullhi_u64(q0.lo, v.lo);
+    q0v.lo = q0.lo*v.lo;
+
+    // Compute u - q0v as u_q0v
+    // This is the remainder
+    u128_t u_q0v = u;
+    u_q0v.hi -= q0v.hi + (u.lo < q0v.lo); // second term is borrow
+    u_q0v.lo -= q0v.lo;
+
+    // Check if u_q0v >= v
+    // This checks if our remainder is larger than the divisor
+    if ((u_q0v.hi > v.hi) ||
+        (u_q0v.hi == v.hi && u_q0v.lo >= v.lo)) {
+        // Increment q0
+        q0.lo += 1;
+        q0.hi += (q0.lo == 0); // carry
+
+        // Subtract v from remainder
+        u_q0v.hi -= v.hi + (u_q0v.lo < v.lo);
+        u_q0v.lo -= v.lo;
+    }
+
+    *r_hi = u_q0v.hi;
+    *r_lo = u_q0v.lo;
+
+    LIBDIVIDE_ASSERT(q0.hi == 0);
+    return q0.lo;
+#endif
+}
+
+////////// UINT32
+
+static inline struct libdivide_u32_t libdivide_internal_u32_gen(uint32_t d, int branchfree) {
+    if (d == 0) {
+        LIBDIVIDE_ERROR("divider must be != 0");
+    }
+
+    struct libdivide_u32_t result;
+    uint32_t floor_log_2_d = 31 - libdivide_count_leading_zeros32(d);
+
+    // Power of 2
+    if ((d & (d - 1)) == 0) {
+        // We need to subtract 1 from the shift value in case of an unsigned
+        // branchfree divider because there is a hardcoded right shift by 1
+        // in its division algorithm. Because of this we also need to add back
+        // 1 in its recovery algorithm.
+        result.magic = 0;
+        result.more = (uint8_t)(floor_log_2_d - (branchfree != 0));
+    } else {
+        uint8_t more;
+        uint32_t rem, proposed_m;
+        proposed_m = libdivide_64_div_32_to_32(1U << floor_log_2_d, 0, d, &rem);
+
+        LIBDIVIDE_ASSERT(rem > 0 && rem < d);
+        const uint32_t e = d - rem;
+
+        // This power works if e < 2**floor_log_2_d.
+        if (!branchfree && (e < (1U << floor_log_2_d))) {
+            // This power works
+            more = floor_log_2_d;
+        } else {
+            // We have to use the general 33-bit algorithm.  We need to compute
+            // (2**power) / d. However, we already have (2**(power-1))/d and
+            // its remainder.  By doubling both, and then correcting the
+            // remainder, we can compute the larger division.
+            // don't care about overflow here - in fact, we expect it
+            proposed_m += proposed_m;
+            const uint32_t twice_rem = rem + rem;
+            if (twice_rem >= d || twice_rem < rem) proposed_m += 1;
+            more = floor_log_2_d | LIBDIVIDE_ADD_MARKER;
+        }
+        result.magic = 1 + proposed_m;
+        result.more = more;
+        // result.more's shift should in general be ceil_log_2_d. But if we
+        // used the smaller power, we subtract one from the shift because we're
+        // using the smaller power. If we're using the larger power, we
+        // subtract one from the shift because it's taken care of by the add
+        // indicator. So floor_log_2_d happens to be correct in both cases.
+    }
+    return result;
+}
+
+struct libdivide_u32_t libdivide_u32_gen(uint32_t d) {
+    return libdivide_internal_u32_gen(d, 0);
+}
+
+struct libdivide_u32_branchfree_t libdivide_u32_branchfree_gen(uint32_t d) {
+    if (d == 1) {
+        LIBDIVIDE_ERROR("branchfree divider must be != 1");
+    }
+    struct libdivide_u32_t tmp = libdivide_internal_u32_gen(d, 1);
+    struct libdivide_u32_branchfree_t ret = {tmp.magic, (uint8_t)(tmp.more & LIBDIVIDE_32_SHIFT_MASK)};
+    return ret;
+}
+
+uint32_t libdivide_u32_do(uint32_t numer, const struct libdivide_u32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return numer >> more;
+    }
+    else {
+        uint32_t q = libdivide_mullhi_u32(denom->magic, numer);
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            uint32_t t = ((numer - q) >> 1) + q;
+            return t >> (more & LIBDIVIDE_32_SHIFT_MASK);
+        }
+        else {
+            // All upper bits are 0,
+            // don't need to mask them off.
+            return q >> more;
+        }
+    }
+}
+
+uint32_t libdivide_u32_branchfree_do(uint32_t numer, const struct libdivide_u32_branchfree_t *denom) {
+    uint32_t q = libdivide_mullhi_u32(denom->magic, numer);
+    uint32_t t = ((numer - q) >> 1) + q;
+    return t >> denom->more;
+}
+
+uint32_t libdivide_u32_recover(const struct libdivide_u32_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+
+    if (!denom->magic) {
+        return 1U << shift;
+    } else if (!(more & LIBDIVIDE_ADD_MARKER)) {
+        // We compute q = n/d = n*m / 2^(32 + shift)
+        // Therefore we have d = 2^(32 + shift) / m
+        // We need to ceil it.
+        // We know d is not a power of 2, so m is not a power of 2,
+        // so we can just add 1 to the floor
+        uint32_t hi_dividend = 1U << shift;
+        uint32_t rem_ignored;
+        return 1 + libdivide_64_div_32_to_32(hi_dividend, 0, denom->magic, &rem_ignored);
+    } else {
+        // Here we wish to compute d = 2^(32+shift+1)/(m+2^32).
+        // Notice (m + 2^32) is a 33 bit number. Use 64 bit division for now
+        // Also note that shift may be as high as 31, so shift + 1 will
+        // overflow. So we have to compute it as 2^(32+shift)/(m+2^32), and
+        // then double the quotient and remainder.
+        uint64_t half_n = 1ULL << (32 + shift);
+        uint64_t d = (1ULL << 32) | denom->magic;
+        // Note that the quotient is guaranteed <= 32 bits, but the remainder
+        // may need 33!
+        uint32_t half_q = (uint32_t)(half_n / d);
+        uint64_t rem = half_n % d;
+        // We computed 2^(32+shift)/(m+2^32)
+        // Need to double it, and then add 1 to the quotient if doubling th
+        // remainder would increase the quotient.
+        // Note that rem<<1 cannot overflow, since rem < d and d is 33 bits
+        uint32_t full_q = half_q + half_q + ((rem<<1) >= d);
+
+        // We rounded down in gen (hence +1)
+        return full_q + 1;
+    }
+}
+
+uint32_t libdivide_u32_branchfree_recover(const struct libdivide_u32_branchfree_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+
+    if (!denom->magic) {
+        return 1U << (shift + 1);
+    } else {
+        // Here we wish to compute d = 2^(32+shift+1)/(m+2^32).
+        // Notice (m + 2^32) is a 33 bit number. Use 64 bit division for now
+        // Also note that shift may be as high as 31, so shift + 1 will
+        // overflow. So we have to compute it as 2^(32+shift)/(m+2^32), and
+        // then double the quotient and remainder.
+        uint64_t half_n = 1ULL << (32 + shift);
+        uint64_t d = (1ULL << 32) | denom->magic;
+        // Note that the quotient is guaranteed <= 32 bits, but the remainder
+        // may need 33!
+        uint32_t half_q = (uint32_t)(half_n / d);
+        uint64_t rem = half_n % d;
+        // We computed 2^(32+shift)/(m+2^32)
+        // Need to double it, and then add 1 to the quotient if doubling th
+        // remainder would increase the quotient.
+        // Note that rem<<1 cannot overflow, since rem < d and d is 33 bits
+        uint32_t full_q = half_q + half_q + ((rem<<1) >= d);
+
+        // We rounded down in gen (hence +1)
+        return full_q + 1;
+    }
+}
+
+/////////// UINT64
+
+static inline struct libdivide_u64_t libdivide_internal_u64_gen(uint64_t d, int branchfree) {
+    if (d == 0) {
+        LIBDIVIDE_ERROR("divider must be != 0");
+    }
+
+    struct libdivide_u64_t result;
+    uint32_t floor_log_2_d = 63 - libdivide_count_leading_zeros64(d);
+
+    // Power of 2
+    if ((d & (d - 1)) == 0) {
+        // We need to subtract 1 from the shift value in case of an unsigned
+        // branchfree divider because there is a hardcoded right shift by 1
+        // in its division algorithm. Because of this we also need to add back
+        // 1 in its recovery algorithm.
+        result.magic = 0;
+        result.more = (uint8_t)(floor_log_2_d - (branchfree != 0));
+    } else {
+        uint64_t proposed_m, rem;
+        uint8_t more;
+        // (1 << (64 + floor_log_2_d)) / d
+        proposed_m = libdivide_128_div_64_to_64(1ULL << floor_log_2_d, 0, d, &rem);
+
+        LIBDIVIDE_ASSERT(rem > 0 && rem < d);
+        const uint64_t e = d - rem;
+
+        // This power works if e < 2**floor_log_2_d.
+        if (!branchfree && e < (1ULL << floor_log_2_d)) {
+            // This power works
+            more = floor_log_2_d;
+        } else {
+            // We have to use the general 65-bit algorithm.  We need to compute
+            // (2**power) / d. However, we already have (2**(power-1))/d and
+            // its remainder. By doubling both, and then correcting the
+            // remainder, we can compute the larger division.
+            // don't care about overflow here - in fact, we expect it
+            proposed_m += proposed_m;
+            const uint64_t twice_rem = rem + rem;
+            if (twice_rem >= d || twice_rem < rem) proposed_m += 1;
+                more = floor_log_2_d | LIBDIVIDE_ADD_MARKER;
+        }
+        result.magic = 1 + proposed_m;
+        result.more = more;
+        // result.more's shift should in general be ceil_log_2_d. But if we
+        // used the smaller power, we subtract one from the shift because we're
+        // using the smaller power. If we're using the larger power, we
+        // subtract one from the shift because it's taken care of by the add
+        // indicator. So floor_log_2_d happens to be correct in both cases,
+        // which is why we do it outside of the if statement.
+    }
+    return result;
+}
+
+struct libdivide_u64_t libdivide_u64_gen(uint64_t d) {
+    return libdivide_internal_u64_gen(d, 0);
+}
+
+struct libdivide_u64_branchfree_t libdivide_u64_branchfree_gen(uint64_t d) {
+    if (d == 1) {
+        LIBDIVIDE_ERROR("branchfree divider must be != 1");
+    }
+    struct libdivide_u64_t tmp = libdivide_internal_u64_gen(d, 1);
+    struct libdivide_u64_branchfree_t ret = {tmp.magic, (uint8_t)(tmp.more & LIBDIVIDE_64_SHIFT_MASK)};
+    return ret;
+}
+
+uint64_t libdivide_u64_do(uint64_t numer, const struct libdivide_u64_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return numer >> more;
+    }
+    else {
+        uint64_t q = libdivide_mullhi_u64(denom->magic, numer);
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            uint64_t t = ((numer - q) >> 1) + q;
+            return t >> (more & LIBDIVIDE_64_SHIFT_MASK);
+        }
+        else {
+             // All upper bits are 0,
+             // don't need to mask them off.
+            return q >> more;
+        }
+    }
+}
+
+uint64_t libdivide_u64_branchfree_do(uint64_t numer, const struct libdivide_u64_branchfree_t *denom) {
+    uint64_t q = libdivide_mullhi_u64(denom->magic, numer);
+    uint64_t t = ((numer - q) >> 1) + q;
+    return t >> denom->more;
+}
+
+uint64_t libdivide_u64_recover(const struct libdivide_u64_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+
+    if (!denom->magic) {
+        return 1ULL << shift;
+    } else if (!(more & LIBDIVIDE_ADD_MARKER)) {
+        // We compute q = n/d = n*m / 2^(64 + shift)
+        // Therefore we have d = 2^(64 + shift) / m
+        // We need to ceil it.
+        // We know d is not a power of 2, so m is not a power of 2,
+        // so we can just add 1 to the floor
+        uint64_t hi_dividend = 1ULL << shift;
+        uint64_t rem_ignored;
+        return 1 + libdivide_128_div_64_to_64(hi_dividend, 0, denom->magic, &rem_ignored);
+    } else {
+        // Here we wish to compute d = 2^(64+shift+1)/(m+2^64).
+        // Notice (m + 2^64) is a 65 bit number. This gets hairy. See
+        // libdivide_u32_recover for more on what we do here.
+        // TODO: do something better than 128 bit math
+
+        // Full n is a (potentially) 129 bit value
+        // half_n is a 128 bit value
+        // Compute the hi half of half_n. Low half is 0.
+        uint64_t half_n_hi = 1ULL << shift, half_n_lo = 0;
+        // d is a 65 bit value. The high bit is always set to 1.
+        const uint64_t d_hi = 1, d_lo = denom->magic;
+        // Note that the quotient is guaranteed <= 64 bits,
+        // but the remainder may need 65!
+        uint64_t r_hi, r_lo;
+        uint64_t half_q = libdivide_128_div_128_to_64(half_n_hi, half_n_lo, d_hi, d_lo, &r_hi, &r_lo);
+        // We computed 2^(64+shift)/(m+2^64)
+        // Double the remainder ('dr') and check if that is larger than d
+        // Note that d is a 65 bit value, so r1 is small and so r1 + r1
+        // cannot overflow
+        uint64_t dr_lo = r_lo + r_lo;
+        uint64_t dr_hi = r_hi + r_hi + (dr_lo < r_lo); // last term is carry
+        int dr_exceeds_d = (dr_hi > d_hi) || (dr_hi == d_hi && dr_lo >= d_lo);
+        uint64_t full_q = half_q + half_q + (dr_exceeds_d ? 1 : 0);
+        return full_q + 1;
+    }
+}
+
+uint64_t libdivide_u64_branchfree_recover(const struct libdivide_u64_branchfree_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+
+    if (!denom->magic) {
+        return 1ULL << (shift + 1);
+    } else {
+        // Here we wish to compute d = 2^(64+shift+1)/(m+2^64).
+        // Notice (m + 2^64) is a 65 bit number. This gets hairy. See
+        // libdivide_u32_recover for more on what we do here.
+        // TODO: do something better than 128 bit math
+
+        // Full n is a (potentially) 129 bit value
+        // half_n is a 128 bit value
+        // Compute the hi half of half_n. Low half is 0.
+        uint64_t half_n_hi = 1ULL << shift, half_n_lo = 0;
+        // d is a 65 bit value. The high bit is always set to 1.
+        const uint64_t d_hi = 1, d_lo = denom->magic;
+        // Note that the quotient is guaranteed <= 64 bits,
+        // but the remainder may need 65!
+        uint64_t r_hi, r_lo;
+        uint64_t half_q = libdivide_128_div_128_to_64(half_n_hi, half_n_lo, d_hi, d_lo, &r_hi, &r_lo);
+        // We computed 2^(64+shift)/(m+2^64)
+        // Double the remainder ('dr') and check if that is larger than d
+        // Note that d is a 65 bit value, so r1 is small and so r1 + r1
+        // cannot overflow
+        uint64_t dr_lo = r_lo + r_lo;
+        uint64_t dr_hi = r_hi + r_hi + (dr_lo < r_lo); // last term is carry
+        int dr_exceeds_d = (dr_hi > d_hi) || (dr_hi == d_hi && dr_lo >= d_lo);
+        uint64_t full_q = half_q + half_q + (dr_exceeds_d ? 1 : 0);
+        return full_q + 1;
+    }
+}
+
+/////////// SINT32
+
+static inline struct libdivide_s32_t libdivide_internal_s32_gen(int32_t d, int branchfree) {
+    if (d == 0) {
+        LIBDIVIDE_ERROR("divider must be != 0");
+    }
+
+    struct libdivide_s32_t result;
+
+    // If d is a power of 2, or negative a power of 2, we have to use a shift.
+    // This is especially important because the magic algorithm fails for -1.
+    // To check if d is a power of 2 or its inverse, it suffices to check
+    // whether its absolute value has exactly one bit set. This works even for
+    // INT_MIN, because abs(INT_MIN) == INT_MIN, and INT_MIN has one bit set
+    // and is a power of 2.
+    uint32_t ud = (uint32_t)d;
+    uint32_t absD = (d < 0) ? -ud : ud;
+    uint32_t floor_log_2_d = 31 - libdivide_count_leading_zeros32(absD);
+    // check if exactly one bit is set,
+    // don't care if absD is 0 since that's divide by zero
+    if ((absD & (absD - 1)) == 0) {
+        // Branchfree and normal paths are exactly the same
+        result.magic = 0;
+        result.more = floor_log_2_d | (d < 0 ? LIBDIVIDE_NEGATIVE_DIVISOR : 0);
+    } else {
+        LIBDIVIDE_ASSERT(floor_log_2_d >= 1);
+
+        uint8_t more;
+        // the dividend here is 2**(floor_log_2_d + 31), so the low 32 bit word
+        // is 0 and the high word is floor_log_2_d - 1
+        uint32_t rem, proposed_m;
+        proposed_m = libdivide_64_div_32_to_32(1U << (floor_log_2_d - 1), 0, absD, &rem);
+        const uint32_t e = absD - rem;
+
+        // We are going to start with a power of floor_log_2_d - 1.
+        // This works if works if e < 2**floor_log_2_d.
+        if (!branchfree && e < (1U << floor_log_2_d)) {
+            // This power works
+            more = floor_log_2_d - 1;
+        } else {
+            // We need to go one higher. This should not make proposed_m
+            // overflow, but it will make it negative when interpreted as an
+            // int32_t.
+            proposed_m += proposed_m;
+            const uint32_t twice_rem = rem + rem;
+            if (twice_rem >= absD || twice_rem < rem) proposed_m += 1;
+            more = floor_log_2_d | LIBDIVIDE_ADD_MARKER;
+        }
+
+        proposed_m += 1;
+        int32_t magic = (int32_t)proposed_m;
+
+        // Mark if we are negative. Note we only negate the magic number in the
+        // branchfull case.
+        if (d < 0) {
+            more |= LIBDIVIDE_NEGATIVE_DIVISOR;
+            if (!branchfree) {
+                magic = -magic;
+            }
+        }
+
+        result.more = more;
+        result.magic = magic;
+    }
+    return result;
+}
+
+struct libdivide_s32_t libdivide_s32_gen(int32_t d) {
+    return libdivide_internal_s32_gen(d, 0);
+}
+
+struct libdivide_s32_branchfree_t libdivide_s32_branchfree_gen(int32_t d) {
+    struct libdivide_s32_t tmp = libdivide_internal_s32_gen(d, 1);
+    struct libdivide_s32_branchfree_t result = {tmp.magic, tmp.more};
+    return result;
+}
+
+int32_t libdivide_s32_do(int32_t numer, const struct libdivide_s32_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+
+    if (!denom->magic) {
+        uint32_t sign = (int8_t)more >> 7;
+        uint32_t mask = (1U << shift) - 1;
+        uint32_t uq = numer + ((numer >> 31) & mask);
+        int32_t q = (int32_t)uq;
+        q >>= shift;
+        q = (q ^ sign) - sign;
+        return q;
+    } else {
+        uint32_t uq = (uint32_t)libdivide_mullhi_s32(denom->magic, numer);
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // must be arithmetic shift and then sign extend
+            int32_t sign = (int8_t)more >> 7;
+            // q += (more < 0 ? -numer : numer)
+            // cast required to avoid UB
+            uq += ((uint32_t)numer ^ sign) - sign;
+        }
+        int32_t q = (int32_t)uq;
+        q >>= shift;
+        q += (q < 0);
+        return q;
+    }
+}
+
+int32_t libdivide_s32_branchfree_do(int32_t numer, const struct libdivide_s32_branchfree_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+    // must be arithmetic shift and then sign extend
+    int32_t sign = (int8_t)more >> 7;
+    int32_t magic = denom->magic;
+    int32_t q = libdivide_mullhi_s32(magic, numer);
+    q += numer;
+
+    // If q is non-negative, we have nothing to do
+    // If q is negative, we want to add either (2**shift)-1 if d is a power of
+    // 2, or (2**shift) if it is not a power of 2
+    uint32_t is_power_of_2 = (magic == 0);
+    uint32_t q_sign = (uint32_t)(q >> 31);
+    q += q_sign & ((1U << shift) - is_power_of_2);
+
+    // Now arithmetic right shift
+    q >>= shift;
+    // Negate if needed
+    q = (q ^ sign) - sign;
+
+    return q;
+}
+
+int32_t libdivide_s32_recover(const struct libdivide_s32_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+    if (!denom->magic) {
+        uint32_t absD = 1U << shift;
+        if (more & LIBDIVIDE_NEGATIVE_DIVISOR) {
+            absD = -absD;
+        }
+        return (int32_t)absD;
+    } else {
+        // Unsigned math is much easier
+        // We negate the magic number only in the branchfull case, and we don't
+        // know which case we're in. However we have enough information to
+        // determine the correct sign of the magic number. The divisor was
+        // negative if LIBDIVIDE_NEGATIVE_DIVISOR is set. If ADD_MARKER is set,
+        // the magic number's sign is opposite that of the divisor.
+        // We want to compute the positive magic number.
+        int negative_divisor = (more & LIBDIVIDE_NEGATIVE_DIVISOR);
+        int magic_was_negated = (more & LIBDIVIDE_ADD_MARKER)
+            ? denom->magic > 0 : denom->magic < 0;
+
+        // Handle the power of 2 case (including branchfree)
+        if (denom->magic == 0) {
+            int32_t result = 1U << shift;
+            return negative_divisor ? -result : result;
+        }
+
+        uint32_t d = (uint32_t)(magic_was_negated ? -denom->magic : denom->magic);
+        uint64_t n = 1ULL << (32 + shift); // this shift cannot exceed 30
+        uint32_t q = (uint32_t)(n / d);
+        int32_t result = (int32_t)q;
+        result += 1;
+        return negative_divisor ? -result : result;
+    }
+}
+
+int32_t libdivide_s32_branchfree_recover(const struct libdivide_s32_branchfree_t *denom) {
+    return libdivide_s32_recover((const struct libdivide_s32_t *)denom);
+}
+
+///////////// SINT64
+
+static inline struct libdivide_s64_t libdivide_internal_s64_gen(int64_t d, int branchfree) {
+    if (d == 0) {
+        LIBDIVIDE_ERROR("divider must be != 0");
+    }
+
+    struct libdivide_s64_t result;
+
+    // If d is a power of 2, or negative a power of 2, we have to use a shift.
+    // This is especially important because the magic algorithm fails for -1.
+    // To check if d is a power of 2 or its inverse, it suffices to check
+    // whether its absolute value has exactly one bit set.  This works even for
+    // INT_MIN, because abs(INT_MIN) == INT_MIN, and INT_MIN has one bit set
+    // and is a power of 2.
+    uint64_t ud = (uint64_t)d;
+    uint64_t absD = (d < 0) ? -ud : ud;
+    uint32_t floor_log_2_d = 63 - libdivide_count_leading_zeros64(absD);
+    // check if exactly one bit is set,
+    // don't care if absD is 0 since that's divide by zero
+    if ((absD & (absD - 1)) == 0) {
+        // Branchfree and non-branchfree cases are the same
+        result.magic = 0;
+        result.more = floor_log_2_d | (d < 0 ? LIBDIVIDE_NEGATIVE_DIVISOR : 0);
+    } else {
+        // the dividend here is 2**(floor_log_2_d + 63), so the low 64 bit word
+        // is 0 and the high word is floor_log_2_d - 1
+        uint8_t more;
+        uint64_t rem, proposed_m;
+        proposed_m = libdivide_128_div_64_to_64(1ULL << (floor_log_2_d - 1), 0, absD, &rem);
+        const uint64_t e = absD - rem;
+
+        // We are going to start with a power of floor_log_2_d - 1.
+        // This works if works if e < 2**floor_log_2_d.
+        if (!branchfree && e < (1ULL << floor_log_2_d)) {
+            // This power works
+            more = floor_log_2_d - 1;
+        } else {
+            // We need to go one higher. This should not make proposed_m
+            // overflow, but it will make it negative when interpreted as an
+            // int32_t.
+            proposed_m += proposed_m;
+            const uint64_t twice_rem = rem + rem;
+            if (twice_rem >= absD || twice_rem < rem) proposed_m += 1;
+            // note that we only set the LIBDIVIDE_NEGATIVE_DIVISOR bit if we
+            // also set ADD_MARKER this is an annoying optimization that
+            // enables algorithm #4 to avoid the mask. However we always set it
+            // in the branchfree case
+            more = floor_log_2_d | LIBDIVIDE_ADD_MARKER;
+        }
+        proposed_m += 1;
+        int64_t magic = (int64_t)proposed_m;
+
+        // Mark if we are negative
+        if (d < 0) {
+            more |= LIBDIVIDE_NEGATIVE_DIVISOR;
+            if (!branchfree) {
+                magic = -magic;
+            }
+        }
+
+        result.more = more;
+        result.magic = magic;
+    }
+    return result;
+}
+
+struct libdivide_s64_t libdivide_s64_gen(int64_t d) {
+    return libdivide_internal_s64_gen(d, 0);
+}
+
+struct libdivide_s64_branchfree_t libdivide_s64_branchfree_gen(int64_t d) {
+    struct libdivide_s64_t tmp = libdivide_internal_s64_gen(d, 1);
+    struct libdivide_s64_branchfree_t ret = {tmp.magic, tmp.more};
+    return ret;
+}
+
+int64_t libdivide_s64_do(int64_t numer, const struct libdivide_s64_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+
+    if (!denom->magic) { // shift path
+        uint64_t mask = (1ULL << shift) - 1;
+        uint64_t uq = numer + ((numer >> 63) & mask);
+        int64_t q = (int64_t)uq;
+        q >>= shift;
+        // must be arithmetic shift and then sign-extend
+        int64_t sign = (int8_t)more >> 7;
+        q = (q ^ sign) - sign;
+        return q;
+    } else {
+        uint64_t uq = (uint64_t)libdivide_mullhi_s64(denom->magic, numer);
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // must be arithmetic shift and then sign extend
+            int64_t sign = (int8_t)more >> 7;
+            // q += (more < 0 ? -numer : numer)
+            // cast required to avoid UB
+            uq += ((uint64_t)numer ^ sign) - sign;
+        }
+        int64_t q = (int64_t)uq;
+        q >>= shift;
+        q += (q < 0);
+        return q;
+    }
+}
+
+int64_t libdivide_s64_branchfree_do(int64_t numer, const struct libdivide_s64_branchfree_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+    // must be arithmetic shift and then sign extend
+    int64_t sign = (int8_t)more >> 7;
+    int64_t magic = denom->magic;
+    int64_t q = libdivide_mullhi_s64(magic, numer);
+    q += numer;
+
+    // If q is non-negative, we have nothing to do.
+    // If q is negative, we want to add either (2**shift)-1 if d is a power of
+    // 2, or (2**shift) if it is not a power of 2.
+    uint64_t is_power_of_2 = (magic == 0);
+    uint64_t q_sign = (uint64_t)(q >> 63);
+    q += q_sign & ((1ULL << shift) - is_power_of_2);
+
+    // Arithmetic right shift
+    q >>= shift;
+    // Negate if needed
+    q = (q ^ sign) - sign;
+
+    return q;
+}
+
+int64_t libdivide_s64_recover(const struct libdivide_s64_t *denom) {
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+    if (denom->magic == 0) { // shift path
+        uint64_t absD = 1ULL << shift;
+        if (more & LIBDIVIDE_NEGATIVE_DIVISOR) {
+            absD = -absD;
+        }
+        return (int64_t)absD;
+    } else {
+        // Unsigned math is much easier
+        int negative_divisor = (more & LIBDIVIDE_NEGATIVE_DIVISOR);
+        int magic_was_negated = (more & LIBDIVIDE_ADD_MARKER)
+            ? denom->magic > 0 : denom->magic < 0;
+
+        uint64_t d = (uint64_t)(magic_was_negated ? -denom->magic : denom->magic);
+        uint64_t n_hi = 1ULL << shift, n_lo = 0;
+        uint64_t rem_ignored;
+        uint64_t q = libdivide_128_div_64_to_64(n_hi, n_lo, d, &rem_ignored);
+        int64_t result = (int64_t)(q + 1);
+        if (negative_divisor) {
+            result = -result;
+        }
+        return result;
+    }
+}
+
+int64_t libdivide_s64_branchfree_recover(const struct libdivide_s64_branchfree_t *denom) {
+    return libdivide_s64_recover((const struct libdivide_s64_t *)denom);
+}
+
+#if defined(LIBDIVIDE_AVX512)
+
+static inline __m512i libdivide_u32_do_vector(__m512i numers, const struct libdivide_u32_t *denom);
+static inline __m512i libdivide_s32_do_vector(__m512i numers, const struct libdivide_s32_t *denom);
+static inline __m512i libdivide_u64_do_vector(__m512i numers, const struct libdivide_u64_t *denom);
+static inline __m512i libdivide_s64_do_vector(__m512i numers, const struct libdivide_s64_t *denom);
+
+static inline __m512i libdivide_u32_branchfree_do_vector(__m512i numers, const struct libdivide_u32_branchfree_t *denom);
+static inline __m512i libdivide_s32_branchfree_do_vector(__m512i numers, const struct libdivide_s32_branchfree_t *denom);
+static inline __m512i libdivide_u64_branchfree_do_vector(__m512i numers, const struct libdivide_u64_branchfree_t *denom);
+static inline __m512i libdivide_s64_branchfree_do_vector(__m512i numers, const struct libdivide_s64_branchfree_t *denom);
+
+//////// Internal Utility Functions
+
+static inline __m512i libdivide_s64_signbits(__m512i v) {;
+    return _mm512_srai_epi64(v, 63);
+}
+
+static inline __m512i libdivide_s64_shift_right_vector(__m512i v, int amt) {
+    return _mm512_srai_epi64(v, amt);
+}
+
+// Here, b is assumed to contain one 32-bit value repeated.
+static inline __m512i libdivide_mullhi_u32_vector(__m512i a, __m512i b) {
+    __m512i hi_product_0Z2Z = _mm512_srli_epi64(_mm512_mul_epu32(a, b), 32);
+    __m512i a1X3X = _mm512_srli_epi64(a, 32);
+    __m512i mask = _mm512_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0);
+    __m512i hi_product_Z1Z3 = _mm512_and_si512(_mm512_mul_epu32(a1X3X, b), mask);
+    return _mm512_or_si512(hi_product_0Z2Z, hi_product_Z1Z3);
+}
+
+// b is one 32-bit value repeated.
+static inline __m512i libdivide_mullhi_s32_vector(__m512i a, __m512i b) {
+    __m512i hi_product_0Z2Z = _mm512_srli_epi64(_mm512_mul_epi32(a, b), 32);
+    __m512i a1X3X = _mm512_srli_epi64(a, 32);
+    __m512i mask = _mm512_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0, -1, 0);
+    __m512i hi_product_Z1Z3 = _mm512_and_si512(_mm512_mul_epi32(a1X3X, b), mask);
+    return _mm512_or_si512(hi_product_0Z2Z, hi_product_Z1Z3);
+}
+
+// Here, y is assumed to contain one 64-bit value repeated.
+// https://stackoverflow.com/a/28827013
+static inline __m512i libdivide_mullhi_u64_vector(__m512i x, __m512i y) {
+    __m512i lomask = _mm512_set1_epi64(0xffffffff);
+    __m512i xh = _mm512_shuffle_epi32(x, (_MM_PERM_ENUM) 0xB1);
+    __m512i yh = _mm512_shuffle_epi32(y, (_MM_PERM_ENUM) 0xB1);
+    __m512i w0 = _mm512_mul_epu32(x, y);
+    __m512i w1 = _mm512_mul_epu32(x, yh);
+    __m512i w2 = _mm512_mul_epu32(xh, y);
+    __m512i w3 = _mm512_mul_epu32(xh, yh);
+    __m512i w0h = _mm512_srli_epi64(w0, 32);
+    __m512i s1 = _mm512_add_epi64(w1, w0h);
+    __m512i s1l = _mm512_and_si512(s1, lomask);
+    __m512i s1h = _mm512_srli_epi64(s1, 32);
+    __m512i s2 = _mm512_add_epi64(w2, s1l);
+    __m512i s2h = _mm512_srli_epi64(s2, 32);
+    __m512i hi = _mm512_add_epi64(w3, s1h);
+            hi = _mm512_add_epi64(hi, s2h);
+
+    return hi;
+}
+
+// y is one 64-bit value repeated.
+static inline __m512i libdivide_mullhi_s64_vector(__m512i x, __m512i y) {
+    __m512i p = libdivide_mullhi_u64_vector(x, y);
+    __m512i t1 = _mm512_and_si512(libdivide_s64_signbits(x), y);
+    __m512i t2 = _mm512_and_si512(libdivide_s64_signbits(y), x);
+    p = _mm512_sub_epi64(p, t1);
+    p = _mm512_sub_epi64(p, t2);
+    return p;
+}
+
+////////// UINT32
+
+__m512i libdivide_u32_do_vector(__m512i numers, const struct libdivide_u32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return _mm512_srli_epi32(numers, more);
+    }
+    else {
+        __m512i q = libdivide_mullhi_u32_vector(numers, _mm512_set1_epi32(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // uint32_t t = ((numer - q) >> 1) + q;
+            // return t >> denom->shift;
+            uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+            __m512i t = _mm512_add_epi32(_mm512_srli_epi32(_mm512_sub_epi32(numers, q), 1), q);
+            return _mm512_srli_epi32(t, shift);
+        }
+        else {
+            return _mm512_srli_epi32(q, more);
+        }
+    }
+}
+
+__m512i libdivide_u32_branchfree_do_vector(__m512i numers, const struct libdivide_u32_branchfree_t *denom) {
+    __m512i q = libdivide_mullhi_u32_vector(numers, _mm512_set1_epi32(denom->magic));
+    __m512i t = _mm512_add_epi32(_mm512_srli_epi32(_mm512_sub_epi32(numers, q), 1), q);
+    return _mm512_srli_epi32(t, denom->more);
+}
+
+////////// UINT64
+
+__m512i libdivide_u64_do_vector(__m512i numers, const struct libdivide_u64_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return _mm512_srli_epi64(numers, more);
+    }
+    else {
+        __m512i q = libdivide_mullhi_u64_vector(numers, _mm512_set1_epi64(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // uint32_t t = ((numer - q) >> 1) + q;
+            // return t >> denom->shift;
+            uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+            __m512i t = _mm512_add_epi64(_mm512_srli_epi64(_mm512_sub_epi64(numers, q), 1), q);
+            return _mm512_srli_epi64(t, shift);
+        }
+        else {
+            return _mm512_srli_epi64(q, more);
+        }
+    }
+}
+
+__m512i libdivide_u64_branchfree_do_vector(__m512i numers, const struct libdivide_u64_branchfree_t *denom) {
+    __m512i q = libdivide_mullhi_u64_vector(numers, _mm512_set1_epi64(denom->magic));
+    __m512i t = _mm512_add_epi64(_mm512_srli_epi64(_mm512_sub_epi64(numers, q), 1), q);
+    return _mm512_srli_epi64(t, denom->more);
+}
+
+////////// SINT32
+
+__m512i libdivide_s32_do_vector(__m512i numers, const struct libdivide_s32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+        uint32_t mask = (1U << shift) - 1;
+        __m512i roundToZeroTweak = _mm512_set1_epi32(mask);
+        // q = numer + ((numer >> 31) & roundToZeroTweak);
+        __m512i q = _mm512_add_epi32(numers, _mm512_and_si512(_mm512_srai_epi32(numers, 31), roundToZeroTweak));
+        q = _mm512_srai_epi32(q, shift);
+        __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
+        // q = (q ^ sign) - sign;
+        q = _mm512_sub_epi32(_mm512_xor_si512(q, sign), sign);
+        return q;
+    }
+    else {
+        __m512i q = libdivide_mullhi_s32_vector(numers, _mm512_set1_epi32(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+             // must be arithmetic shift
+            __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
+             // q += ((numer ^ sign) - sign);
+            q = _mm512_add_epi32(q, _mm512_sub_epi32(_mm512_xor_si512(numers, sign), sign));
+        }
+        // q >>= shift
+        q = _mm512_srai_epi32(q, more & LIBDIVIDE_32_SHIFT_MASK);
+        q = _mm512_add_epi32(q, _mm512_srli_epi32(q, 31)); // q += (q < 0)
+        return q;
+    }
+}
+
+__m512i libdivide_s32_branchfree_do_vector(__m512i numers, const struct libdivide_s32_branchfree_t *denom) {
+    int32_t magic = denom->magic;
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+     // must be arithmetic shift
+    __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
+    __m512i q = libdivide_mullhi_s32_vector(numers, _mm512_set1_epi32(magic));
+    q = _mm512_add_epi32(q, numers); // q += numers
+
+    // If q is non-negative, we have nothing to do
+    // If q is negative, we want to add either (2**shift)-1 if d is
+    // a power of 2, or (2**shift) if it is not a power of 2
+    uint32_t is_power_of_2 = (magic == 0);
+    __m512i q_sign = _mm512_srai_epi32(q, 31); // q_sign = q >> 31
+    __m512i mask = _mm512_set1_epi32((1U << shift) - is_power_of_2);
+    q = _mm512_add_epi32(q, _mm512_and_si512(q_sign, mask)); // q = q + (q_sign & mask)
+    q = _mm512_srai_epi32(q, shift); // q >>= shift
+    q = _mm512_sub_epi32(_mm512_xor_si512(q, sign), sign); // q = (q ^ sign) - sign
+    return q;
+}
+
+////////// SINT64
+
+__m512i libdivide_s64_do_vector(__m512i numers, const struct libdivide_s64_t *denom) {
+    uint8_t more = denom->more;
+    int64_t magic = denom->magic;
+    if (magic == 0) { // shift path
+        uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+        uint64_t mask = (1ULL << shift) - 1;
+        __m512i roundToZeroTweak = _mm512_set1_epi64(mask);
+        // q = numer + ((numer >> 63) & roundToZeroTweak);
+        __m512i q = _mm512_add_epi64(numers, _mm512_and_si512(libdivide_s64_signbits(numers), roundToZeroTweak));
+        q = libdivide_s64_shift_right_vector(q, shift);
+        __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
+         // q = (q ^ sign) - sign;
+        q = _mm512_sub_epi64(_mm512_xor_si512(q, sign), sign);
+        return q;
+    }
+    else {
+        __m512i q = libdivide_mullhi_s64_vector(numers, _mm512_set1_epi64(magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // must be arithmetic shift
+            __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
+            // q += ((numer ^ sign) - sign);
+            q = _mm512_add_epi64(q, _mm512_sub_epi64(_mm512_xor_si512(numers, sign), sign));
+        }
+        // q >>= denom->mult_path.shift
+        q = libdivide_s64_shift_right_vector(q, more & LIBDIVIDE_64_SHIFT_MASK);
+        q = _mm512_add_epi64(q, _mm512_srli_epi64(q, 63)); // q += (q < 0)
+        return q;
+    }
+}
+
+__m512i libdivide_s64_branchfree_do_vector(__m512i numers, const struct libdivide_s64_branchfree_t *denom) {
+    int64_t magic = denom->magic;
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+    // must be arithmetic shift
+    __m512i sign = _mm512_set1_epi32((int8_t)more >> 7);
+
+     // libdivide_mullhi_s64(numers, magic);
+    __m512i q = libdivide_mullhi_s64_vector(numers, _mm512_set1_epi64(magic));
+    q = _mm512_add_epi64(q, numers); // q += numers
+
+    // If q is non-negative, we have nothing to do.
+    // If q is negative, we want to add either (2**shift)-1 if d is
+    // a power of 2, or (2**shift) if it is not a power of 2.
+    uint32_t is_power_of_2 = (magic == 0);
+    __m512i q_sign = libdivide_s64_signbits(q); // q_sign = q >> 63
+    __m512i mask = _mm512_set1_epi64((1ULL << shift) - is_power_of_2);
+    q = _mm512_add_epi64(q, _mm512_and_si512(q_sign, mask)); // q = q + (q_sign & mask)
+    q = libdivide_s64_shift_right_vector(q, shift); // q >>= shift
+    q = _mm512_sub_epi64(_mm512_xor_si512(q, sign), sign); // q = (q ^ sign) - sign
+    return q;
+}
+
+#elif defined(LIBDIVIDE_AVX2)
+
+static inline __m256i libdivide_u32_do_vector(__m256i numers, const struct libdivide_u32_t *denom);
+static inline __m256i libdivide_s32_do_vector(__m256i numers, const struct libdivide_s32_t *denom);
+static inline __m256i libdivide_u64_do_vector(__m256i numers, const struct libdivide_u64_t *denom);
+static inline __m256i libdivide_s64_do_vector(__m256i numers, const struct libdivide_s64_t *denom);
+
+static inline __m256i libdivide_u32_branchfree_do_vector(__m256i numers, const struct libdivide_u32_branchfree_t *denom);
+static inline __m256i libdivide_s32_branchfree_do_vector(__m256i numers, const struct libdivide_s32_branchfree_t *denom);
+static inline __m256i libdivide_u64_branchfree_do_vector(__m256i numers, const struct libdivide_u64_branchfree_t *denom);
+static inline __m256i libdivide_s64_branchfree_do_vector(__m256i numers, const struct libdivide_s64_branchfree_t *denom);
+
+//////// Internal Utility Functions
+
+// Implementation of _mm256_srai_epi64(v, 63) (from AVX512).
+static inline __m256i libdivide_s64_signbits(__m256i v) {
+    __m256i hiBitsDuped = _mm256_shuffle_epi32(v, _MM_SHUFFLE(3, 3, 1, 1));
+    __m256i signBits = _mm256_srai_epi32(hiBitsDuped, 31);
+    return signBits;
+}
+
+// Implementation of _mm256_srai_epi64 (from AVX512).
+static inline __m256i libdivide_s64_shift_right_vector(__m256i v, int amt) {
+    const int b = 64 - amt;
+    __m256i m = _mm256_set1_epi64x(1ULL << (b - 1));
+    __m256i x = _mm256_srli_epi64(v, amt);
+    __m256i result = _mm256_sub_epi64(_mm256_xor_si256(x, m), m);
+    return result;
+}
+
+// Here, b is assumed to contain one 32-bit value repeated.
+static inline __m256i libdivide_mullhi_u32_vector(__m256i a, __m256i b) {
+    __m256i hi_product_0Z2Z = _mm256_srli_epi64(_mm256_mul_epu32(a, b), 32);
+    __m256i a1X3X = _mm256_srli_epi64(a, 32);
+    __m256i mask = _mm256_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0);
+    __m256i hi_product_Z1Z3 = _mm256_and_si256(_mm256_mul_epu32(a1X3X, b), mask);
+    return _mm256_or_si256(hi_product_0Z2Z, hi_product_Z1Z3);
+}
+
+// b is one 32-bit value repeated.
+static inline __m256i libdivide_mullhi_s32_vector(__m256i a, __m256i b) {
+    __m256i hi_product_0Z2Z = _mm256_srli_epi64(_mm256_mul_epi32(a, b), 32);
+    __m256i a1X3X = _mm256_srli_epi64(a, 32);
+    __m256i mask = _mm256_set_epi32(-1, 0, -1, 0, -1, 0, -1, 0);
+    __m256i hi_product_Z1Z3 = _mm256_and_si256(_mm256_mul_epi32(a1X3X, b), mask);
+    return _mm256_or_si256(hi_product_0Z2Z, hi_product_Z1Z3);
+}
+
+// Here, y is assumed to contain one 64-bit value repeated.
+// https://stackoverflow.com/a/28827013
+static inline __m256i libdivide_mullhi_u64_vector(__m256i x, __m256i y) {
+    __m256i lomask = _mm256_set1_epi64x(0xffffffff);
+    __m256i xh = _mm256_shuffle_epi32(x, 0xB1);        // x0l, x0h, x1l, x1h
+    __m256i yh = _mm256_shuffle_epi32(y, 0xB1);        // y0l, y0h, y1l, y1h
+    __m256i w0 = _mm256_mul_epu32(x, y);               // x0l*y0l, x1l*y1l
+    __m256i w1 = _mm256_mul_epu32(x, yh);              // x0l*y0h, x1l*y1h
+    __m256i w2 = _mm256_mul_epu32(xh, y);              // x0h*y0l, x1h*y0l
+    __m256i w3 = _mm256_mul_epu32(xh, yh);             // x0h*y0h, x1h*y1h
+    __m256i w0h = _mm256_srli_epi64(w0, 32);
+    __m256i s1 = _mm256_add_epi64(w1, w0h);
+    __m256i s1l = _mm256_and_si256(s1, lomask);
+    __m256i s1h = _mm256_srli_epi64(s1, 32);
+    __m256i s2 = _mm256_add_epi64(w2, s1l);
+    __m256i s2h = _mm256_srli_epi64(s2, 32);
+    __m256i hi = _mm256_add_epi64(w3, s1h);
+            hi = _mm256_add_epi64(hi, s2h);
+
+    return hi;
+}
+
+// y is one 64-bit value repeated.
+static inline __m256i libdivide_mullhi_s64_vector(__m256i x, __m256i y) {
+    __m256i p = libdivide_mullhi_u64_vector(x, y);
+    __m256i t1 = _mm256_and_si256(libdivide_s64_signbits(x), y);
+    __m256i t2 = _mm256_and_si256(libdivide_s64_signbits(y), x);
+    p = _mm256_sub_epi64(p, t1);
+    p = _mm256_sub_epi64(p, t2);
+    return p;
+}
+
+////////// UINT32
+
+__m256i libdivide_u32_do_vector(__m256i numers, const struct libdivide_u32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return _mm256_srli_epi32(numers, more);
+    }
+    else {
+        __m256i q = libdivide_mullhi_u32_vector(numers, _mm256_set1_epi32(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // uint32_t t = ((numer - q) >> 1) + q;
+            // return t >> denom->shift;
+            uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+            __m256i t = _mm256_add_epi32(_mm256_srli_epi32(_mm256_sub_epi32(numers, q), 1), q);
+            return _mm256_srli_epi32(t, shift);
+        }
+        else {
+            return _mm256_srli_epi32(q, more);
+        }
+    }
+}
+
+__m256i libdivide_u32_branchfree_do_vector(__m256i numers, const struct libdivide_u32_branchfree_t *denom) {
+    __m256i q = libdivide_mullhi_u32_vector(numers, _mm256_set1_epi32(denom->magic));
+    __m256i t = _mm256_add_epi32(_mm256_srli_epi32(_mm256_sub_epi32(numers, q), 1), q);
+    return _mm256_srli_epi32(t, denom->more);
+}
+
+////////// UINT64
+
+__m256i libdivide_u64_do_vector(__m256i numers, const struct libdivide_u64_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return _mm256_srli_epi64(numers, more);
+    }
+    else {
+        __m256i q = libdivide_mullhi_u64_vector(numers, _mm256_set1_epi64x(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // uint32_t t = ((numer - q) >> 1) + q;
+            // return t >> denom->shift;
+            uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+            __m256i t = _mm256_add_epi64(_mm256_srli_epi64(_mm256_sub_epi64(numers, q), 1), q);
+            return _mm256_srli_epi64(t, shift);
+        }
+        else {
+            return _mm256_srli_epi64(q, more);
+        }
+    }
+}
+
+__m256i libdivide_u64_branchfree_do_vector(__m256i numers, const struct libdivide_u64_branchfree_t *denom) {
+    __m256i q = libdivide_mullhi_u64_vector(numers, _mm256_set1_epi64x(denom->magic));
+    __m256i t = _mm256_add_epi64(_mm256_srli_epi64(_mm256_sub_epi64(numers, q), 1), q);
+    return _mm256_srli_epi64(t, denom->more);
+}
+
+////////// SINT32
+
+__m256i libdivide_s32_do_vector(__m256i numers, const struct libdivide_s32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+        uint32_t mask = (1U << shift) - 1;
+        __m256i roundToZeroTweak = _mm256_set1_epi32(mask);
+        // q = numer + ((numer >> 31) & roundToZeroTweak);
+        __m256i q = _mm256_add_epi32(numers, _mm256_and_si256(_mm256_srai_epi32(numers, 31), roundToZeroTweak));
+        q = _mm256_srai_epi32(q, shift);
+        __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
+        // q = (q ^ sign) - sign;
+        q = _mm256_sub_epi32(_mm256_xor_si256(q, sign), sign);
+        return q;
+    }
+    else {
+        __m256i q = libdivide_mullhi_s32_vector(numers, _mm256_set1_epi32(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+             // must be arithmetic shift
+            __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
+             // q += ((numer ^ sign) - sign);
+            q = _mm256_add_epi32(q, _mm256_sub_epi32(_mm256_xor_si256(numers, sign), sign));
+        }
+        // q >>= shift
+        q = _mm256_srai_epi32(q, more & LIBDIVIDE_32_SHIFT_MASK);
+        q = _mm256_add_epi32(q, _mm256_srli_epi32(q, 31)); // q += (q < 0)
+        return q;
+    }
+}
+
+__m256i libdivide_s32_branchfree_do_vector(__m256i numers, const struct libdivide_s32_branchfree_t *denom) {
+    int32_t magic = denom->magic;
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+     // must be arithmetic shift
+    __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
+    __m256i q = libdivide_mullhi_s32_vector(numers, _mm256_set1_epi32(magic));
+    q = _mm256_add_epi32(q, numers); // q += numers
+
+    // If q is non-negative, we have nothing to do
+    // If q is negative, we want to add either (2**shift)-1 if d is
+    // a power of 2, or (2**shift) if it is not a power of 2
+    uint32_t is_power_of_2 = (magic == 0);
+    __m256i q_sign = _mm256_srai_epi32(q, 31); // q_sign = q >> 31
+    __m256i mask = _mm256_set1_epi32((1U << shift) - is_power_of_2);
+    q = _mm256_add_epi32(q, _mm256_and_si256(q_sign, mask)); // q = q + (q_sign & mask)
+    q = _mm256_srai_epi32(q, shift); // q >>= shift
+    q = _mm256_sub_epi32(_mm256_xor_si256(q, sign), sign); // q = (q ^ sign) - sign
+    return q;
+}
+
+////////// SINT64
+
+__m256i libdivide_s64_do_vector(__m256i numers, const struct libdivide_s64_t *denom) {
+    uint8_t more = denom->more;
+    int64_t magic = denom->magic;
+    if (magic == 0) { // shift path
+        uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+        uint64_t mask = (1ULL << shift) - 1;
+        __m256i roundToZeroTweak = _mm256_set1_epi64x(mask);
+        // q = numer + ((numer >> 63) & roundToZeroTweak);
+        __m256i q = _mm256_add_epi64(numers, _mm256_and_si256(libdivide_s64_signbits(numers), roundToZeroTweak));
+        q = libdivide_s64_shift_right_vector(q, shift);
+        __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
+         // q = (q ^ sign) - sign;
+        q = _mm256_sub_epi64(_mm256_xor_si256(q, sign), sign);
+        return q;
+    }
+    else {
+        __m256i q = libdivide_mullhi_s64_vector(numers, _mm256_set1_epi64x(magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // must be arithmetic shift
+            __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
+            // q += ((numer ^ sign) - sign);
+            q = _mm256_add_epi64(q, _mm256_sub_epi64(_mm256_xor_si256(numers, sign), sign));
+        }
+        // q >>= denom->mult_path.shift
+        q = libdivide_s64_shift_right_vector(q, more & LIBDIVIDE_64_SHIFT_MASK);
+        q = _mm256_add_epi64(q, _mm256_srli_epi64(q, 63)); // q += (q < 0)
+        return q;
+    }
+}
+
+__m256i libdivide_s64_branchfree_do_vector(__m256i numers, const struct libdivide_s64_branchfree_t *denom) {
+    int64_t magic = denom->magic;
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+    // must be arithmetic shift
+    __m256i sign = _mm256_set1_epi32((int8_t)more >> 7);
+
+     // libdivide_mullhi_s64(numers, magic);
+    __m256i q = libdivide_mullhi_s64_vector(numers, _mm256_set1_epi64x(magic));
+    q = _mm256_add_epi64(q, numers); // q += numers
+
+    // If q is non-negative, we have nothing to do.
+    // If q is negative, we want to add either (2**shift)-1 if d is
+    // a power of 2, or (2**shift) if it is not a power of 2.
+    uint32_t is_power_of_2 = (magic == 0);
+    __m256i q_sign = libdivide_s64_signbits(q); // q_sign = q >> 63
+    __m256i mask = _mm256_set1_epi64x((1ULL << shift) - is_power_of_2);
+    q = _mm256_add_epi64(q, _mm256_and_si256(q_sign, mask)); // q = q + (q_sign & mask)
+    q = libdivide_s64_shift_right_vector(q, shift); // q >>= shift
+    q = _mm256_sub_epi64(_mm256_xor_si256(q, sign), sign); // q = (q ^ sign) - sign
+    return q;
+}
+
+#elif defined(LIBDIVIDE_SSE2)
+
+static inline __m128i libdivide_u32_do_vector(__m128i numers, const struct libdivide_u32_t *denom);
+static inline __m128i libdivide_s32_do_vector(__m128i numers, const struct libdivide_s32_t *denom);
+static inline __m128i libdivide_u64_do_vector(__m128i numers, const struct libdivide_u64_t *denom);
+static inline __m128i libdivide_s64_do_vector(__m128i numers, const struct libdivide_s64_t *denom);
+
+static inline __m128i libdivide_u32_branchfree_do_vector(__m128i numers, const struct libdivide_u32_branchfree_t *denom);
+static inline __m128i libdivide_s32_branchfree_do_vector(__m128i numers, const struct libdivide_s32_branchfree_t *denom);
+static inline __m128i libdivide_u64_branchfree_do_vector(__m128i numers, const struct libdivide_u64_branchfree_t *denom);
+static inline __m128i libdivide_s64_branchfree_do_vector(__m128i numers, const struct libdivide_s64_branchfree_t *denom);
+
+//////// Internal Utility Functions
+
+// Implementation of _mm_srai_epi64(v, 63) (from AVX512).
+static inline __m128i libdivide_s64_signbits(__m128i v) {
+    __m128i hiBitsDuped = _mm_shuffle_epi32(v, _MM_SHUFFLE(3, 3, 1, 1));
+    __m128i signBits = _mm_srai_epi32(hiBitsDuped, 31);
+    return signBits;
+}
+
+// Implementation of _mm_srai_epi64 (from AVX512).
+static inline __m128i libdivide_s64_shift_right_vector(__m128i v, int amt) {
+    const int b = 64 - amt;
+    __m128i m = _mm_set1_epi64x(1ULL << (b - 1));
+    __m128i x = _mm_srli_epi64(v, amt);
+    __m128i result = _mm_sub_epi64(_mm_xor_si128(x, m), m);
+    return result;
+}
+
+// Here, b is assumed to contain one 32-bit value repeated.
+static inline __m128i libdivide_mullhi_u32_vector(__m128i a, __m128i b) {
+    __m128i hi_product_0Z2Z = _mm_srli_epi64(_mm_mul_epu32(a, b), 32);
+    __m128i a1X3X = _mm_srli_epi64(a, 32);
+    __m128i mask = _mm_set_epi32(-1, 0, -1, 0);
+    __m128i hi_product_Z1Z3 = _mm_and_si128(_mm_mul_epu32(a1X3X, b), mask);
+    return _mm_or_si128(hi_product_0Z2Z, hi_product_Z1Z3);
+}
+
+// SSE2 does not have a signed multiplication instruction, but we can convert
+// unsigned to signed pretty efficiently. Again, b is just a 32 bit value
+// repeated four times.
+static inline __m128i libdivide_mullhi_s32_vector(__m128i a, __m128i b) {
+    __m128i p = libdivide_mullhi_u32_vector(a, b);
+    // t1 = (a >> 31) & y, arithmetic shift
+    __m128i t1 = _mm_and_si128(_mm_srai_epi32(a, 31), b);
+    __m128i t2 = _mm_and_si128(_mm_srai_epi32(b, 31), a);
+    p = _mm_sub_epi32(p, t1);
+    p = _mm_sub_epi32(p, t2);
+    return p;
+}
+
+// Here, y is assumed to contain one 64-bit value repeated.
+// https://stackoverflow.com/a/28827013
+static inline __m128i libdivide_mullhi_u64_vector(__m128i x, __m128i y) {
+    __m128i lomask = _mm_set1_epi64x(0xffffffff);
+    __m128i xh = _mm_shuffle_epi32(x, 0xB1);        // x0l, x0h, x1l, x1h
+    __m128i yh = _mm_shuffle_epi32(y, 0xB1);        // y0l, y0h, y1l, y1h
+    __m128i w0 = _mm_mul_epu32(x, y);               // x0l*y0l, x1l*y1l
+    __m128i w1 = _mm_mul_epu32(x, yh);              // x0l*y0h, x1l*y1h
+    __m128i w2 = _mm_mul_epu32(xh, y);              // x0h*y0l, x1h*y0l
+    __m128i w3 = _mm_mul_epu32(xh, yh);             // x0h*y0h, x1h*y1h
+    __m128i w0h = _mm_srli_epi64(w0, 32);
+    __m128i s1 = _mm_add_epi64(w1, w0h);
+    __m128i s1l = _mm_and_si128(s1, lomask);
+    __m128i s1h = _mm_srli_epi64(s1, 32);
+    __m128i s2 = _mm_add_epi64(w2, s1l);
+    __m128i s2h = _mm_srli_epi64(s2, 32);
+    __m128i hi = _mm_add_epi64(w3, s1h);
+            hi = _mm_add_epi64(hi, s2h);
+
+    return hi;
+}
+
+// y is one 64-bit value repeated.
+static inline __m128i libdivide_mullhi_s64_vector(__m128i x, __m128i y) {
+    __m128i p = libdivide_mullhi_u64_vector(x, y);
+    __m128i t1 = _mm_and_si128(libdivide_s64_signbits(x), y);
+    __m128i t2 = _mm_and_si128(libdivide_s64_signbits(y), x);
+    p = _mm_sub_epi64(p, t1);
+    p = _mm_sub_epi64(p, t2);
+    return p;
+}
+
+////////// UINT32
+
+__m128i libdivide_u32_do_vector(__m128i numers, const struct libdivide_u32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return _mm_srli_epi32(numers, more);
+    }
+    else {
+        __m128i q = libdivide_mullhi_u32_vector(numers, _mm_set1_epi32(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // uint32_t t = ((numer - q) >> 1) + q;
+            // return t >> denom->shift;
+            uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+            __m128i t = _mm_add_epi32(_mm_srli_epi32(_mm_sub_epi32(numers, q), 1), q);
+            return _mm_srli_epi32(t, shift);
+        }
+        else {
+            return _mm_srli_epi32(q, more);
+        }
+    }
+}
+
+__m128i libdivide_u32_branchfree_do_vector(__m128i numers, const struct libdivide_u32_branchfree_t *denom) {
+    __m128i q = libdivide_mullhi_u32_vector(numers, _mm_set1_epi32(denom->magic));
+    __m128i t = _mm_add_epi32(_mm_srli_epi32(_mm_sub_epi32(numers, q), 1), q);
+    return _mm_srli_epi32(t, denom->more);
+}
+
+////////// UINT64
+
+__m128i libdivide_u64_do_vector(__m128i numers, const struct libdivide_u64_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        return _mm_srli_epi64(numers, more);
+    }
+    else {
+        __m128i q = libdivide_mullhi_u64_vector(numers, _mm_set1_epi64x(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // uint32_t t = ((numer - q) >> 1) + q;
+            // return t >> denom->shift;
+            uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+            __m128i t = _mm_add_epi64(_mm_srli_epi64(_mm_sub_epi64(numers, q), 1), q);
+            return _mm_srli_epi64(t, shift);
+        }
+        else {
+            return _mm_srli_epi64(q, more);
+        }
+    }
+}
+
+__m128i libdivide_u64_branchfree_do_vector(__m128i numers, const struct libdivide_u64_branchfree_t *denom) {
+    __m128i q = libdivide_mullhi_u64_vector(numers, _mm_set1_epi64x(denom->magic));
+    __m128i t = _mm_add_epi64(_mm_srli_epi64(_mm_sub_epi64(numers, q), 1), q);
+    return _mm_srli_epi64(t, denom->more);
+}
+
+////////// SINT32
+
+__m128i libdivide_s32_do_vector(__m128i numers, const struct libdivide_s32_t *denom) {
+    uint8_t more = denom->more;
+    if (!denom->magic) {
+        uint32_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+        uint32_t mask = (1U << shift) - 1;
+        __m128i roundToZeroTweak = _mm_set1_epi32(mask);
+        // q = numer + ((numer >> 31) & roundToZeroTweak);
+        __m128i q = _mm_add_epi32(numers, _mm_and_si128(_mm_srai_epi32(numers, 31), roundToZeroTweak));
+        q = _mm_srai_epi32(q, shift);
+        __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
+        // q = (q ^ sign) - sign;
+        q = _mm_sub_epi32(_mm_xor_si128(q, sign), sign);
+        return q;
+    }
+    else {
+        __m128i q = libdivide_mullhi_s32_vector(numers, _mm_set1_epi32(denom->magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+             // must be arithmetic shift
+            __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
+             // q += ((numer ^ sign) - sign);
+            q = _mm_add_epi32(q, _mm_sub_epi32(_mm_xor_si128(numers, sign), sign));
+        }
+        // q >>= shift
+        q = _mm_srai_epi32(q, more & LIBDIVIDE_32_SHIFT_MASK);
+        q = _mm_add_epi32(q, _mm_srli_epi32(q, 31)); // q += (q < 0)
+        return q;
+    }
+}
+
+__m128i libdivide_s32_branchfree_do_vector(__m128i numers, const struct libdivide_s32_branchfree_t *denom) {
+    int32_t magic = denom->magic;
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_32_SHIFT_MASK;
+     // must be arithmetic shift
+    __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
+    __m128i q = libdivide_mullhi_s32_vector(numers, _mm_set1_epi32(magic));
+    q = _mm_add_epi32(q, numers); // q += numers
+
+    // If q is non-negative, we have nothing to do
+    // If q is negative, we want to add either (2**shift)-1 if d is
+    // a power of 2, or (2**shift) if it is not a power of 2
+    uint32_t is_power_of_2 = (magic == 0);
+    __m128i q_sign = _mm_srai_epi32(q, 31); // q_sign = q >> 31
+    __m128i mask = _mm_set1_epi32((1U << shift) - is_power_of_2);
+    q = _mm_add_epi32(q, _mm_and_si128(q_sign, mask)); // q = q + (q_sign & mask)
+    q = _mm_srai_epi32(q, shift); // q >>= shift
+    q = _mm_sub_epi32(_mm_xor_si128(q, sign), sign); // q = (q ^ sign) - sign
+    return q;
+}
+
+////////// SINT64
+
+__m128i libdivide_s64_do_vector(__m128i numers, const struct libdivide_s64_t *denom) {
+    uint8_t more = denom->more;
+    int64_t magic = denom->magic;
+    if (magic == 0) { // shift path
+        uint32_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+        uint64_t mask = (1ULL << shift) - 1;
+        __m128i roundToZeroTweak = _mm_set1_epi64x(mask);
+        // q = numer + ((numer >> 63) & roundToZeroTweak);
+        __m128i q = _mm_add_epi64(numers, _mm_and_si128(libdivide_s64_signbits(numers), roundToZeroTweak));
+        q = libdivide_s64_shift_right_vector(q, shift);
+        __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
+         // q = (q ^ sign) - sign;
+        q = _mm_sub_epi64(_mm_xor_si128(q, sign), sign);
+        return q;
+    }
+    else {
+        __m128i q = libdivide_mullhi_s64_vector(numers, _mm_set1_epi64x(magic));
+        if (more & LIBDIVIDE_ADD_MARKER) {
+            // must be arithmetic shift
+            __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
+            // q += ((numer ^ sign) - sign);
+            q = _mm_add_epi64(q, _mm_sub_epi64(_mm_xor_si128(numers, sign), sign));
+        }
+        // q >>= denom->mult_path.shift
+        q = libdivide_s64_shift_right_vector(q, more & LIBDIVIDE_64_SHIFT_MASK);
+        q = _mm_add_epi64(q, _mm_srli_epi64(q, 63)); // q += (q < 0)
+        return q;
+    }
+}
+
+__m128i libdivide_s64_branchfree_do_vector(__m128i numers, const struct libdivide_s64_branchfree_t *denom) {
+    int64_t magic = denom->magic;
+    uint8_t more = denom->more;
+    uint8_t shift = more & LIBDIVIDE_64_SHIFT_MASK;
+    // must be arithmetic shift
+    __m128i sign = _mm_set1_epi32((int8_t)more >> 7);
+
+     // libdivide_mullhi_s64(numers, magic);
+    __m128i q = libdivide_mullhi_s64_vector(numers, _mm_set1_epi64x(magic));
+    q = _mm_add_epi64(q, numers); // q += numers
+
+    // If q is non-negative, we have nothing to do.
+    // If q is negative, we want to add either (2**shift)-1 if d is
+    // a power of 2, or (2**shift) if it is not a power of 2.
+    uint32_t is_power_of_2 = (magic == 0);
+    __m128i q_sign = libdivide_s64_signbits(q); // q_sign = q >> 63
+    __m128i mask = _mm_set1_epi64x((1ULL << shift) - is_power_of_2);
+    q = _mm_add_epi64(q, _mm_and_si128(q_sign, mask)); // q = q + (q_sign & mask)
+    q = libdivide_s64_shift_right_vector(q, shift); // q >>= shift
+    q = _mm_sub_epi64(_mm_xor_si128(q, sign), sign); // q = (q ^ sign) - sign
+    return q;
+}
+
+#endif
+
+/////////// C++ stuff
+
+#ifdef __cplusplus
+
+// The C++ divider class is templated on both an integer type
+// (like uint64_t) and an algorithm type.
+// * BRANCHFULL is the default algorithm type.
+// * BRANCHFREE is the branchfree algorithm type.
+enum {
+    BRANCHFULL,
+    BRANCHFREE
+};
+
+#if defined(LIBDIVIDE_AVX512)
+    #define LIBDIVIDE_VECTOR_TYPE __m512i
+#elif defined(LIBDIVIDE_AVX2)
+    #define LIBDIVIDE_VECTOR_TYPE __m256i
+#elif defined(LIBDIVIDE_SSE2)
+    #define LIBDIVIDE_VECTOR_TYPE __m128i
+#endif
+
+#if !defined(LIBDIVIDE_VECTOR_TYPE)
+    #define LIBDIVIDE_DIVIDE_VECTOR(ALGO)
+#else
+    #define LIBDIVIDE_DIVIDE_VECTOR(ALGO) \
+        LIBDIVIDE_VECTOR_TYPE divide(LIBDIVIDE_VECTOR_TYPE n) const { \
+            return libdivide_##ALGO##_do_vector(n, &denom); \
+        }
+#endif
+
+// The DISPATCHER_GEN() macro generates C++ methods (for the given integer
+// and algorithm types) that redirect to libdivide's C API.
+#define DISPATCHER_GEN(T, ALGO) \
+    libdivide_##ALGO##_t denom; \
+    dispatcher() { } \
+    dispatcher(T d) \
+        : denom(libdivide_##ALGO##_gen(d)) \
+    { } \
+    T divide(T n) const { \
+        return libdivide_##ALGO##_do(n, &denom); \
+    } \
+    LIBDIVIDE_DIVIDE_VECTOR(ALGO) \
+    T recover() const { \
+        return libdivide_##ALGO##_recover(&denom); \
+    }
+
+// The dispatcher selects a specific division algorithm for a given
+// type and ALGO using partial template specialization.
+template<bool IS_INTEGRAL, bool IS_SIGNED, int SIZEOF, int ALGO> struct dispatcher { };
+
+template<> struct dispatcher<true, true, sizeof(int32_t), BRANCHFULL> { DISPATCHER_GEN(int32_t, s32) };
+template<> struct dispatcher<true, true, sizeof(int32_t), BRANCHFREE> { DISPATCHER_GEN(int32_t, s32_branchfree) };
+template<> struct dispatcher<true, false, sizeof(uint32_t), BRANCHFULL> { DISPATCHER_GEN(uint32_t, u32) };
+template<> struct dispatcher<true, false, sizeof(uint32_t), BRANCHFREE> { DISPATCHER_GEN(uint32_t, u32_branchfree) };
+template<> struct dispatcher<true, true, sizeof(int64_t), BRANCHFULL> { DISPATCHER_GEN(int64_t, s64) };
+template<> struct dispatcher<true, true, sizeof(int64_t), BRANCHFREE> { DISPATCHER_GEN(int64_t, s64_branchfree) };
+template<> struct dispatcher<true, false, sizeof(uint64_t), BRANCHFULL> { DISPATCHER_GEN(uint64_t, u64) };
+template<> struct dispatcher<true, false, sizeof(uint64_t), BRANCHFREE> { DISPATCHER_GEN(uint64_t, u64_branchfree) };
+
+// This is the main divider class for use by the user (C++ API).
+// The actual division algorithm is selected using the dispatcher struct
+// based on the integer and algorithm template parameters.
+template<typename T, int ALGO = BRANCHFULL>
+class divider {
+public:
+    // We leave the default constructor empty so that creating
+    // an array of dividers and then initializing them
+    // later doesn't slow us down.
+    divider() { }
+
+    // Constructor that takes the divisor as a parameter
+    divider(T d) : div(d) { }
+
+    // Divides n by the divisor
+    T divide(T n) const {
+        return div.divide(n);
+    }
+
+    // Recovers the divisor, returns the value that was
+    // used to initialize this divider object.
+    T recover() const {
+        return div.recover();
+    }
+
+    bool operator==(const divider<T, ALGO>& other) const {
+        return div.denom.magic == other.denom.magic &&
+               div.denom.more == other.denom.more;
+    }
+
+    bool operator!=(const divider<T, ALGO>& other) const {
+        return !(*this == other);
+    }
+
+#if defined(LIBDIVIDE_VECTOR_TYPE)
+    // Treats the vector as packed integer values with the same type as
+    // the divider (e.g. s32, u32, s64, u64) and divides each of
+    // them by the divider, returning the packed quotients.
+    LIBDIVIDE_VECTOR_TYPE divide(LIBDIVIDE_VECTOR_TYPE n) const {
+        return div.divide(n);
+    }
+#endif
+
+private:
+    // Storage for the actual divisor
+    dispatcher<std::is_integral<T>::value,
+               std::is_signed<T>::value, sizeof(T), ALGO> div;
+};
+
+// Overload of operator / for scalar division
+template<typename T, int ALGO>
+T operator/(T n, const divider<T, ALGO>& div) {
+    return div.divide(n);
+}
+
+// Overload of operator /= for scalar division
+template<typename T, int ALGO>
+T& operator/=(T& n, const divider<T, ALGO>& div) {
+    n = div.divide(n);
+    return n;
+}
+
+#if defined(LIBDIVIDE_VECTOR_TYPE)
+    // Overload of operator / for vector division
+    template<typename T, int ALGO>
+    LIBDIVIDE_VECTOR_TYPE operator/(LIBDIVIDE_VECTOR_TYPE n, const divider<T, ALGO>& div) {
+        return div.divide(n);
+    }
+    // Overload of operator /= for vector division
+    template<typename T, int ALGO>
+    LIBDIVIDE_VECTOR_TYPE& operator/=(LIBDIVIDE_VECTOR_TYPE& n, const divider<T, ALGO>& div) {
+        n = div.divide(n);
+        return n;
+    }
+#endif
+
+// libdivdie::branchfree_divider<T>
+template <typename T>
+using branchfree_divider = divider<T, BRANCHFREE>;
+
+}  // namespace libdivide
+
+#endif  // __cplusplus
+
+#endif  // NUMPY_CORE_INCLUDE_NUMPY_LIBDIVIDE_LIBDIVIDE_H_

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/astype_copy.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9564b309cbf3441ff0a6e4468fddaca46230fab34f15c77d87025a455bdf59d9
+size 716

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-arccosh.csv

@@ -0,0 +1,1429 @@
+dtype,input,output,ulperrortol
+np.float32,0x3f83203f,0x3e61d9d6,2
+np.float32,0x3f98dea1,0x3f1d1af6,2
+np.float32,0x7fa00000,0x7fe00000,2
+np.float32,0x7eba99af,0x42b0d032,2
+np.float32,0x3fc95a13,0x3f833650,2
+np.float32,0x3fce9a45,0x3f8771e1,2
+np.float32,0x3fc1bd96,0x3f797811,2
+np.float32,0x7eba2391,0x42b0ceed,2
+np.float32,0x7d4e8f15,0x42acdb8c,2
+np.float32,0x3feca42e,0x3f9cc88e,2
+np.float32,0x7e2b314e,0x42af412e,2
+np.float32,0x7f7fffff,0x42b2d4fc,2
+np.float32,0x3f803687,0x3d6c4380,2
+np.float32,0x3fa0edbd,0x3f33e706,2
+np.float32,0x3faa8074,0x3f4b3d3c,2
+np.float32,0x3fa0c49e,0x3f337af3,2
+np.float32,0x3f8c9ec4,0x3ee18812,2
+np.float32,0x7efef78e,0x42b17006,2
+np.float32,0x3fc75720,0x3f818aa4,2
+np.float32,0x7f52d4c8,0x42b27198,2
+np.float32,0x3f88f21e,0x3ebe52b0,2
+np.float32,0x3ff7a042,0x3fa3a07a,2
+np.float32,0x7f52115c,0x42b26fbd,2
+np.float32,0x3fc6bf6f,0x3f810b42,2
+np.float32,0x3fd105d0,0x3f895649,2
+np.float32,0x3fee7c2a,0x3f9df66e,2
+np.float32,0x7f0ff9a5,0x42b1ae4f,2
+np.float32,0x7e81f075,0x42b016e7,2
+np.float32,0x3fa57d65,0x3f3f70c6,2
+np.float32,0x80800000,0xffc00000,2
+np.float32,0x7da239f5,0x42adc2bf,2
+np.float32,0x3f9e432c,0x3f2cbd80,2
+np.float32,0x3ff2839b,0x3fa07ee4,2
+np.float32,0x3fec8aef,0x3f9cb850,2
+np.float32,0x7d325893,0x42ac905b,2
+np.float32,0x3fa27431,0x3f37dade,2
+np.float32,0x3fce7408,0x3f8753ae,2
+np.float32,0x3fde6684,0x3f93353f,2
+np.float32,0x3feb9a3e,0x3f9c1cff,2
+np.float32,0x7deb34bb,0x42ae80f0,2
+np.float32,0x3fed9300,0x3f9d61b7,2
+np.float32,0x7f35e253,0x42b225fb,2
+np.float32,0x7e6db57f,0x42afe93f,2
+np.float32,0x3fa41f08,0x3f3c10bc,2
+np.float32,0x3fb0d4da,0x3f590de3,2
+np.float32,0x3fb5c690,0x3f632351,2
+np.float32,0x3fcde9ce,0x3f86e638,2
+np.float32,0x3f809c7b,0x3dc81161,2
+np.float32,0x3fd77291,0x3f8e3226,2
+np.float32,0x3fc21a06,0x3f7a1a82,2
+np.float32,0x3fba177e,0x3f6b8139,2
+np.float32,0x7f370dff,0x42b22944,2
+np.float32,0x3fe5bfcc,0x3f9841c1,2
+np.float32,0x3feb0caa,0x3f9bc139,2
+np.float32,0x7f4fe5c3,0x42b26a6c,2
+np.float32,0x7f1e1419,0x42b1de28,2
+np.float32,0x7f5e3c96,0x42b28c92,2
+np.float32,0x3f8cd313,0x3ee3521e,2
+np.float32,0x3fa97824,0x3f48e049,2
+np.float32,0x7d8ca281,0x42ad799e,2
+np.float32,0x3f96b51b,0x3f165193,2
+np.float32,0x3f81328a,0x3e0bf504,2
+np.float32,0x3ff60bf3,0x3fa2ab45,2
+np.float32,0x3ff9b629,0x3fa4e107,2
+np.float32,0x3fecacfc,0x3f9cce37,2
+np.float32,0x3fba8804,0x3f6c5600,2
+np.float32,0x3f81f752,0x3e333fdd,2
+np.float32,0x3fb5b262,0x3f62fb46,2
+np.float32,0x3fa21bc0,0x3f36f7e6,2
+np.float32,0x3fbc87bb,0x3f7011dc,2
+np.float32,0x3fe18b32,0x3f9565ae,2
+np.float32,0x7dfb6dd5,0x42aea316,2
+np.float32,0x3fb7c602,0x3f670ee3,2
+np.float32,0x7efeb6a2,0x42b16f84,2
+np.float32,0x3fa56180,0x3f3f2ca4,2
+np.float32,0x3f8dcaff,0x3eeb9ac0,2
+np.float32,0x7e876238,0x42b02beb,2
+np.float32,0x7f0bb67d,0x42b19eec,2
+np.float32,0x3faca01c,0x3f4fffa5,2
+np.float32,0x3fdb57ee,0x3f9108b8,2
+np.float32,0x3fe3bade,0x3f96e4b7,2
+np.float32,0x7f7aa2dd,0x42b2ca25,2
+np.float32,0x3fed92ec,0x3f9d61aa,2
+np.float32,0x7eb789b1,0x42b0c7b9,2
+np.float32,0x7f7f16e4,0x42b2d329,2
+np.float32,0x3fb6647e,0x3f645b84,2
+np.float32,0x3f99335e,0x3f1e1d96,2
+np.float32,0x7e690a11,0x42afdf17,2
+np.float32,0x7dff2f95,0x42aeaaae,2
+np.float32,0x7f70adfd,0x42b2b564,2
+np.float32,0x3fe92252,0x3f9a80fe,2
+np.float32,0x3fef54ce,0x3f9e7fe5,2
+np.float32,0x3ff24eaa,0x3fa05df9,2
+np.float32,0x7f04565a,0x42b18328,2
+np.float32,0x3fcb8b80,0x3f85007f,2
+np.float32,0x3fcd4d0a,0x3f866983,2
+np.float32,0x3fbe7d82,0x3f73a911,2
+np.float32,0x3f8a7a8a,0x3ecdc8f6,2
+np.float32,0x3f912441,0x3f030d56,2
+np.float32,0x3f9b29d6,0x3f23f663,2
+np.float32,0x3fab7f36,0x3f4d7c6c,2
+np.float32,0x7dfedafc,0x42aeaa04,2
+np.float32,0x3fe190c0,0x3f956982,2
+np.float32,0x3f927515,0x3f07e0bb,2
+np.float32,0x3ff6442a,0x3fa2cd7e,2
+np.float32,0x7f6656d0,0x42b29ee8,2
+np.float32,0x3fe29aa0,0x3f96201f,2
+np.float32,0x3fa4a247,0x3f3d5687,2
+np.float32,0x3fa1cf19,0x3f363226,2
+np.float32,0x3fc20037,0x3f79ed36,2
+np.float32,0x7cc1241a,0x42ab5645,2
+np.float32,0x3fafd540,0x3f56f25a,2
+np.float32,0x7e5b3f5f,0x42afbfdb,2
+np.float32,0x7f48de5f,0x42b258d0,2
+np.float32,0x3fce1ca0,0x3f870e85,2
+np.float32,0x7ee40bb2,0x42b136e4,2
+np.float32,0x7ecdb133,0x42b10212,2
+np.float32,0x3f9f181c,0x3f2f02ca,2
+np.float32,0x3f936cbf,0x3f0b4f63,2
+np.float32,0x3fa4f8ea,0x3f3e2c2f,2
+np.float32,0x3fcc03e2,0x3f8561ac,2
+np.float32,0x3fb801f2,0x3f67831b,2
+np.float32,0x7e141dad,0x42aef70c,2
+np.float32,0x3fe8c04e,0x3f9a4087,2
+np.float32,0x3f8548d5,0x3e929f37,2
+np.float32,0x7f148d7d,0x42b1be56,2
+np.float32,0x3fd2c9a2,0x3f8ab1ed,2
+np.float32,0x7eb374fd,0x42b0bc36,2
+np.float32,0x7f296d36,0x42b201a7,2
+np.float32,0x3ff138e2,0x3f9fb09d,2
+np.float32,0x3ff42898,0x3fa18347,2
+np.float32,0x7da8c5e1,0x42add700,2
+np.float32,0x7dcf72c4,0x42ae40a4,2
+np.float32,0x7ea571fc,0x42b09296,2
+np.float32,0x3fc0953d,0x3f776ba3,2
+np.float32,0x7f1773dd,0x42b1c83c,2
+np.float32,0x7ef53b68,0x42b15c17,2
+np.float32,0x3f85d69f,0x3e9a0f3a,2
+np.float32,0x7e8b9a05,0x42b03ba0,2
+np.float32,0x3ff07d20,0x3f9f3ad2,2
+np.float32,0x7e8da32c,0x42b0430a,2
+np.float32,0x7ef96004,0x42b164ab,2
+np.float32,0x3fdfaa62,0x3f941837,2
+np.float32,0x7f0057c5,0x42b17377,2
+np.float32,0x3fb2663f,0x3f5c5065,2
+np.float32,0x3fd3d8c3,0x3f8b8055,2
+np.float32,0x1,0xffc00000,2
+np.float32,0x3fd536c1,0x3f8c8862,2
+np.float32,0x3f91b953,0x3f053619,2
+np.float32,0x3fb3305c,0x3f5deee1,2
+np.float32,0x7ecd86b9,0x42b101a8,2
+np.float32,0x3fbf71c5,0x3f75624d,2
+np.float32,0x3ff5f0f4,0x3fa29ad2,2
+np.float32,0x3fe50389,0x3f97c328,2
+np.float32,0x3fa325a1,0x3f399e69,2
+np.float32,0x3fe4397a,0x3f973a9f,2
+np.float32,0x3f8684c6,0x3ea2b784,2
+np.float32,0x7f25ae00,0x42b1f634,2
+np.float32,0x3ff7cbf7,0x3fa3badb,2
+np.float32,0x7f73f0e0,0x42b2bc48,2
+np.float32,0x3fc88b70,0x3f828b92,2
+np.float32,0x3fb01c16,0x3f578886,2
+np.float32,0x7e557623,0x42afb229,2
+np.float32,0x3fcbcd5b,0x3f8535b4,2
+np.float32,0x7f7157e4,0x42b2b6cd,2
+np.float32,0x7f51d9d4,0x42b26f36,2
+np.float32,0x7f331a3b,0x42b21e17,2
+np.float32,0x7f777fb5,0x42b2c3b2,2
+np.float32,0x3f832001,0x3e61d11f,2
+np.float32,0x7f2cd055,0x42b20bca,2
+np.float32,0x3f89831f,0x3ec42f76,2
+np.float32,0x7f21da33,0x42b1ea3d,2
+np.float32,0x3f99e416,0x3f20330a,2
+np.float32,0x7f2c8ea1,0x42b20b07,2
+np.float32,0x7f462c98,0x42b251e6,2
+np.float32,0x7f4fdb3f,0x42b26a52,2
+np.float32,0x3fcc1338,0x3f856e07,2
+np.float32,0x3f823673,0x3e3e20da,2
+np.float32,0x7dbfe89d,0x42ae18c6,2
+np.float32,0x3fc9b04c,0x3f837d38,2
+np.float32,0x7dba3213,0x42ae094d,2
+np.float32,0x7ec5a483,0x42b0eda1,2
+np.float32,0x3fbc4d14,0x3f6fa543,2
+np.float32,0x3fc85ce2,0x3f8264f1,2
+np.float32,0x7f77c816,0x42b2c447,2
+np.float32,0x3f9c9281,0x3f280492,2
+np.float32,0x7f49b3e2,0x42b25aef,2
+np.float32,0x3fa7e4da,0x3f45347c,2
+np.float32,0x7e0c9df5,0x42aedc72,2
+np.float32,0x7f21fd1a,0x42b1eaab,2
+np.float32,0x7f7c63ad,0x42b2cdb6,2
+np.float32,0x7f4eb80a,0x42b26783,2
+np.float32,0x7e98038c,0x42b0673c,2
+np.float32,0x7e89ba08,0x42b034b4,2
+np.float32,0x3ffc06ba,0x3fa64094,2
+np.float32,0x3fae63f6,0x3f53db36,2
+np.float32,0x3fbc2d30,0x3f6f6a1c,2
+np.float32,0x7de0e5e5,0x42ae69fe,2
+np.float32,0x7e09ed18,0x42aed28d,2
+np.float32,0x3fea78f8,0x3f9b6129,2
+np.float32,0x7dfe0bcc,0x42aea863,2
+np.float32,0x7ee21d03,0x42b13289,2
+np.float32,0x3fcc3aed,0x3f858dfc,2
+np.float32,0x3fe6b3ba,0x3f98e4ea,2
+np.float32,0x3f90f25f,0x3f025225,2
+np.float32,0x7f1bcaf4,0x42b1d6b3,2
+np.float32,0x3f83ac81,0x3e74c20e,2
+np.float32,0x3f98681d,0x3f1bae16,2
+np.float32,0x3fe1f2d9,0x3f95ad08,2
+np.float32,0x3fa279d7,0x3f37e951,2
+np.float32,0x3feb922a,0x3f9c17c4,2
+np.float32,0x7f1c72e8,0x42b1d8da,2
+np.float32,0x3fea156b,0x3f9b2038,2
+np.float32,0x3fed6bda,0x3f9d48aa,2
+np.float32,0x3fa86142,0x3f46589c,2
+np.float32,0x3ff16bc2,0x3f9fd072,2
+np.float32,0x3fbebf65,0x3f74207b,2
+np.float32,0x7e7b78b5,0x42b00610,2
+np.float32,0x3ff51ab8,0x3fa217f0,2
+np.float32,0x3f8361bb,0x3e6adf07,2
+np.float32,0x7edbceed,0x42b1240e,2
+np.float32,0x7f10e2c0,0x42b1b18a,2
+np.float32,0x3fa7bc58,0x3f44d4ef,2
+np.float32,0x3f813bde,0x3e0e1138,2
+np.float32,0x7f30d5b9,0x42b21791,2
+np.float32,0x3fb4f450,0x3f61806a,2
+np.float32,0x7eee02c4,0x42b14cca,2
+np.float32,0x7ec74b62,0x42b0f1e4,2
+np.float32,0x3ff96bca,0x3fa4b498,2
+np.float32,0x7f50e304,0x42b26cda,2
+np.float32,0x7eb14c57,0x42b0b603,2
+np.float32,0x7c3f0733,0x42a9edbf,2
+np.float32,0x7ea57acb,0x42b092b1,2
+np.float32,0x7f2788dc,0x42b1fbe7,2
+np.float32,0x3fa39f14,0x3f3ad09b,2
+np.float32,0x3fc3a7e0,0x3f7ccfa0,2
+np.float32,0x3fe70a73,0x3f991eb0,2
+np.float32,0x7f4831f7,0x42b25718,2
+np.float32,0x3fe947d0,0x3f9a999c,2
+np.float32,0x7ef2b1c7,0x42b156c4,2
+np.float32,0x3fede0ea,0x3f9d937f,2
+np.float32,0x3f9fef8e,0x3f314637,2
+np.float32,0x3fc313c5,0x3f7bcebd,2
+np.float32,0x7ee99337,0x42b14328,2
+np.float32,0x7eb9042e,0x42b0cbd5,2
+np.float32,0x3fc9d3dc,0x3f839a69,2
+np.float32,0x3fb2c018,0x3f5d091d,2
+np.float32,0x3fcc4e8f,0x3f859dc5,2
+np.float32,0x3fa9363b,0x3f484819,2
+np.float32,0x7f72ce2e,0x42b2b9e4,2
+np.float32,0x7e639326,0x42afd2f1,2
+np.float32,0x7f4595d3,0x42b25060,2
+np.float32,0x7f6d0ac4,0x42b2ad97,2
+np.float32,0x7f1bda0d,0x42b1d6e5,2
+np.float32,0x3fd85ffd,0x3f8ee0ed,2
+np.float32,0x3f91d53f,0x3f059c8e,2
+np.float32,0x7d06e103,0x42ac0155,2
+np.float32,0x3fb83126,0x3f67de6e,2
+np.float32,0x7d81ce1f,0x42ad5097,2
+np.float32,0x7f79cb3b,0x42b2c86b,2
+np.float32,0x7f800000,0x7f800000,2
+np.float32,0x3fdbfffd,0x3f918137,2
+np.float32,0x7f4ecb1c,0x42b267b2,2
+np.float32,0x3fc2c122,0x3f7b3ed3,2
+np.float32,0x7f415854,0x42b24544,2
+np.float32,0x7e3d988b,0x42af7575,2
+np.float32,0x3f83ca99,0x3e789fcb,2
+np.float32,0x7f274f70,0x42b1fb38,2
+np.float32,0x7f0d20e6,0x42b1a416,2
+np.float32,0x3fdf3a1d,0x3f93c9c1,2
+np.float32,0x7efaa13e,0x42b1673d,2
+np.float32,0x3fb20b15,0x3f5b9434,2
+np.float32,0x3f86af9f,0x3ea4c664,2
+np.float32,0x3fe4fcb0,0x3f97be8a,2
+np.float32,0x3f920683,0x3f065085,2
+np.float32,0x3fa4b278,0x3f3d7e8b,2
+np.float32,0x3f8077a8,0x3daef77f,2
+np.float32,0x7e865be4,0x42b02807,2
+np.float32,0x3fcea7e2,0x3f877c9f,2
+np.float32,0x7e7e9db1,0x42b00c6d,2
+np.float32,0x3f9819aa,0x3f1aba7e,2
+np.float32,0x7f2b6c4b,0x42b207a7,2
+np.float32,0x7ef85e3e,0x42b16299,2
+np.float32,0x3fbd8290,0x3f71df8b,2
+np.float32,0x3fbbb615,0x3f6e8c8c,2
+np.float32,0x7f1bc7f5,0x42b1d6a9,2
+np.float32,0x3fbb4fea,0x3f6dcdad,2
+np.float32,0x3fb67e09,0x3f648dd1,2
+np.float32,0x3fc83495,0x3f824374,2
+np.float32,0x3fe52980,0x3f97dcbc,2
+np.float32,0x3f87d893,0x3eb25d7c,2
+np.float32,0x3fdb805a,0x3f9125c0,2
+np.float32,0x3fb33f0f,0x3f5e0ce1,2
+np.float32,0x3facc524,0x3f50516b,2
+np.float32,0x3ff40484,0x3fa16d0e,2
+np.float32,0x3ff078bf,0x3f9f3811,2
+np.float32,0x7f736747,0x42b2bb27,2
+np.float32,0x7f55768b,0x42b277f3,2
+np.float32,0x80000001,0xffc00000,2
+np.float32,0x7f6463d1,0x42b29a8e,2
+np.float32,0x3f8f8b59,0x3ef9d792,2
+np.float32,0x3f8a6f4d,0x3ecd5bf4,2
+np.float32,0x3fe958d9,0x3f9aa4ca,2
+np.float32,0x7f1e2ce2,0x42b1de78,2
+np.float32,0x3fb8584a,0x3f682a05,2
+np.float32,0x7dea3dc6,0x42ae7ed5,2
+np.float32,0x7f53a815,0x42b27399,2
+np.float32,0x7e0cf986,0x42aeddbf,2
+np.float32,0x7f3afb71,0x42b23422,2
+np.float32,0x3fd87d6e,0x3f8ef685,2
+np.float32,0x3ffcaa46,0x3fa6a0d7,2
+np.float32,0x7eecd276,0x42b14a3a,2
+np.float32,0x3ffc30b4,0x3fa65951,2
+np.float32,0x7e9c85e2,0x42b07634,2
+np.float32,0x3f95d862,0x3f1383de,2
+np.float32,0x7ef21410,0x42b15577,2
+np.float32,0x3fbfa1b5,0x3f75b86e,2
+np.float32,0x3fd6d90f,0x3f8dc086,2
+np.float32,0x0,0xffc00000,2
+np.float32,0x7e885dcd,0x42b02f9f,2
+np.float32,0x3fb3e057,0x3f5f54bf,2
+np.float32,0x7f40afdd,0x42b24385,2
+np.float32,0x3fb795c2,0x3f66b120,2
+np.float32,0x3fba7c11,0x3f6c3f73,2
+np.float32,0x3ffef620,0x3fa7f828,2
+np.float32,0x7d430508,0x42acbe1e,2
+np.float32,0x3f8d2892,0x3ee6369f,2
+np.float32,0x3fbea139,0x3f73e9d5,2
+np.float32,0x3ffaa928,0x3fa571b9,2
+np.float32,0x7fc00000,0x7fc00000,2
+np.float32,0x7f16f9ce,0x42b1c69f,2
+np.float32,0x3fa8f753,0x3f47b657,2
+np.float32,0x3fd48a63,0x3f8c06ac,2
+np.float32,0x7f13419e,0x42b1b9d9,2
+np.float32,0x3fdf1526,0x3f93afde,2
+np.float32,0x3f903c8b,0x3eff3be8,2
+np.float32,0x7f085323,0x42b1925b,2
+np.float32,0x7cdbe309,0x42ab98ac,2
+np.float32,0x3fba2cfd,0x3f6ba9f1,2
+np.float32,0x7f5a805d,0x42b283e4,2
+np.float32,0x7f6753dd,0x42b2a119,2
+np.float32,0x3fed9f02,0x3f9d6964,2
+np.float32,0x3f96422c,0x3f14ddba,2
+np.float32,0x7f22f2a9,0x42b1edb1,2
+np.float32,0x3fe3fcfd,0x3f97119d,2
+np.float32,0x7e018ad0,0x42aeb271,2
+np.float32,0x7db896f5,0x42ae04de,2
+np.float32,0x7e55c795,0x42afb2ec,2
+np.float32,0x7f58ef8d,0x42b28036,2
+np.float32,0x7f24a16a,0x42b1f2f3,2
+np.float32,0x3fcf714c,0x3f881b09,2
+np.float32,0x3fcdd056,0x3f86d200,2
+np.float32,0x7f02fad0,0x42b17de0,2
+np.float32,0x7eeab877,0x42b145a9,2
+np.float32,0x3fd6029d,0x3f8d20f7,2
+np.float32,0x3fd4f8cd,0x3f8c59d6,2
+np.float32,0x3fb29d4a,0x3f5cc1a5,2
+np.float32,0x3fb11e2d,0x3f59a77a,2
+np.float32,0x7eded576,0x42b12b0e,2
+np.float32,0x7f26c2a5,0x42b1f988,2
+np.float32,0x3fb6165b,0x3f63c151,2
+np.float32,0x7f3bca47,0x42b23657,2
+np.float32,0x7d8c93bf,0x42ad7968,2
+np.float32,0x3f8ede02,0x3ef47176,2
+np.float32,0x3fbef762,0x3f7485b9,2
+np.float32,0x7f1419af,0x42b1bcc6,2
+np.float32,0x7d9e8c79,0x42adb701,2
+np.float32,0x3fa26336,0x3f37af63,2
+np.float32,0x7f5f5590,0x42b28f18,2
+np.float32,0x3fddc93a,0x3f92c651,2
+np.float32,0x3ff0a5fc,0x3f9f547f,2
+np.float32,0x3fb2f6b8,0x3f5d790e,2
+np.float32,0x3ffe59a4,0x3fa79d2c,2
+np.float32,0x7e4df848,0x42af9fde,2
+np.float32,0x3fb0ab3b,0x3f58b678,2
+np.float32,0x7ea54d47,0x42b09225,2
+np.float32,0x3fdd6404,0x3f927eb2,2
+np.float32,0x3f846dc0,0x3e864caa,2
+np.float32,0x7d046aee,0x42abf7e7,2
+np.float32,0x7f7c5a05,0x42b2cda3,2
+np.float32,0x3faf6126,0x3f55fb21,2
+np.float32,0x7f36a910,0x42b22829,2
+np.float32,0x3fdc7b36,0x3f91d938,2
+np.float32,0x3fff443e,0x3fa82577,2
+np.float32,0x7ee7154a,0x42b13daa,2
+np.float32,0x3f944742,0x3f0e435c,2
+np.float32,0x7f5b510a,0x42b285cc,2
+np.float32,0x3f9bc940,0x3f25c4d2,2
+np.float32,0x3fee4782,0x3f9dd4ea,2
+np.float32,0x3fcfc2dd,0x3f885aea,2
+np.float32,0x7eab65cf,0x42b0a4af,2
+np.float32,0x3f9cf908,0x3f292689,2
+np.float32,0x7ed35501,0x42b10feb,2
+np.float32,0x7dabb70a,0x42addfd9,2
+np.float32,0x7f348919,0x42b2222b,2
+np.float32,0x3fb137d4,0x3f59dd17,2
+np.float32,0x7e7b36c9,0x42b0058a,2
+np.float32,0x7e351fa4,0x42af5e0d,2
+np.float32,0x3f973c0c,0x3f18011e,2
+np.float32,0xff800000,0xffc00000,2
+np.float32,0x3f9b0a4b,0x3f239a33,2
+np.float32,0x3f87c4cf,0x3eb17e7e,2
+np.float32,0x7ef67760,0x42b15eaa,2
+np.float32,0x3fc4d2c8,0x3f7ed20f,2
+np.float32,0x7e940dac,0x42b059b8,2
+np.float32,0x7f6e6a52,0x42b2b08d,2
+np.float32,0x3f838752,0x3e6fe4b2,2
+np.float32,0x3fd8f046,0x3f8f4a94,2
+np.float32,0x3fa82112,0x3f45c223,2
+np.float32,0x3fd49b16,0x3f8c1345,2
+np.float32,0x7f02a941,0x42b17ca1,2
+np.float32,0x3f8a9d2c,0x3ecf1768,2
+np.float32,0x7c9372e3,0x42aacc0f,2
+np.float32,0x3fd260b3,0x3f8a619a,2
+np.float32,0x3f8a1b88,0x3eca27cb,2
+np.float32,0x7d25d510,0x42ac6b1c,2
+np.float32,0x7ef5a578,0x42b15cf5,2
+np.float32,0x3fe6625d,0x3f98ae9a,2
+np.float32,0x3ff53240,0x3fa22658,2
+np.float32,0x3f8bb2e6,0x3ed944cf,2
+np.float32,0x7f4679b1,0x42b252ad,2
+np.float32,0x3fa8db30,0x3f4774fc,2
+np.float32,0x7ee5fafd,0x42b13b37,2
+np.float32,0x3fc405e0,0x3f7d71fb,2
+np.float32,0x3f9303cd,0x3f09ddfd,2
+np.float32,0x7f486e67,0x42b257b2,2
+np.float32,0x7e73f12b,0x42aff680,2
+np.float32,0x3fe80f8b,0x3f99cbe4,2
+np.float32,0x3f84200a,0x3e81a3f3,2
+np.float32,0x3fa14e5c,0x3f34e3ce,2
+np.float32,0x3fda22ec,0x3f9029bb,2
+np.float32,0x3f801772,0x3d1aef98,2
+np.float32,0x7eaa1428,0x42b0a0bb,2
+np.float32,0x3feae0b3,0x3f9ba4aa,2
+np.float32,0x7ea439b4,0x42b08ecc,2
+np.float32,0x3fa28b1c,0x3f381579,2
+np.float32,0x7e8af247,0x42b03937,2
+np.float32,0x3fd19216,0x3f89c2b7,2
+np.float32,0x7f6ea033,0x42b2b100,2
+np.float32,0x3fad4fbf,0x3f518224,2
+np.float32,0x3febd940,0x3f9c45bd,2
+np.float32,0x7f4643a3,0x42b25221,2
+np.float32,0x7ec34478,0x42b0e771,2
+np.float32,0x7f18c83b,0x42b1ccb5,2
+np.float32,0x3fc665ad,0x3f80bf94,2
+np.float32,0x3ff0a999,0x3f9f56c4,2
+np.float32,0x3faf1cd2,0x3f5568fe,2
+np.float32,0x7ecd9dc6,0x42b101e1,2
+np.float32,0x3faad282,0x3f4bf754,2
+np.float32,0x3ff905a0,0x3fa47771,2
+np.float32,0x7f596481,0x42b28149,2
+np.float32,0x7f1cb31f,0x42b1d9ac,2
+np.float32,0x7e266719,0x42af32a6,2
+np.float32,0x7eccce06,0x42b0ffdb,2
+np.float32,0x3f9b6f71,0x3f24c102,2
+np.float32,0x3f80e4ba,0x3df1d6bc,2
+np.float32,0x3f843d51,0x3e836a60,2
+np.float32,0x7f70bd88,0x42b2b585,2
+np.float32,0x3fe4cc96,0x3f979e18,2
+np.float32,0x3ff737c7,0x3fa36151,2
+np.float32,0x3ff1197e,0x3f9f9cf4,2
+np.float32,0x7f08e190,0x42b19471,2
+np.float32,0x3ff1542e,0x3f9fc1b2,2
+np.float32,0x3ff6673c,0x3fa2e2d2,2
+np.float32,0xbf800000,0xffc00000,2
+np.float32,0x7e3f9ba7,0x42af7add,2
+np.float32,0x7f658ff6,0x42b29d2d,2
+np.float32,0x3f93441c,0x3f0ac0d9,2
+np.float32,0x7f526a74,0x42b27096,2
+np.float32,0x7f5b00c8,0x42b28511,2
+np.float32,0x3ff212f8,0x3fa038cf,2
+np.float32,0x7e0bd60d,0x42aed998,2
+np.float32,0x7f71ef7f,0x42b2b80e,2
+np.float32,0x7f7a897e,0x42b2c9f1,2
+np.float32,0x7e8b76a6,0x42b03b1e,2
+np.float32,0x7efa0da3,0x42b1660f,2
+np.float32,0x3fce9166,0x3f876ae0,2
+np.float32,0x3fc4163d,0x3f7d8e30,2
+np.float32,0x3fdb3784,0x3f90f16b,2
+np.float32,0x7c5f177b,0x42aa3d30,2
+np.float32,0x3fc6276d,0x3f808af5,2
+np.float32,0x7bac9cc2,0x42a856f4,2
+np.float32,0x3fe5876f,0x3f981bea,2
+np.float32,0x3fef60e3,0x3f9e878a,2
+np.float32,0x3fb23cd8,0x3f5bfb06,2
+np.float32,0x3fe114e2,0x3f951402,2
+np.float32,0x7ca8ef04,0x42ab11b4,2
+np.float32,0x7d93c2ad,0x42ad92ec,2
+np.float32,0x3fe5bb8a,0x3f983ee6,2
+np.float32,0x7f0182fd,0x42b1781b,2
+np.float32,0x7da63bb2,0x42adcf3d,2
+np.float32,0x3fac46b7,0x3f4f399e,2
+np.float32,0x7f7a5d8f,0x42b2c997,2
+np.float32,0x7f76572e,0x42b2c14b,2
+np.float32,0x7f42d53e,0x42b24931,2
+np.float32,0x7f7ffd00,0x42b2d4f6,2
+np.float32,0x3fc346c3,0x3f7c2756,2
+np.float32,0x7f1f6ae3,0x42b1e27a,2
+np.float32,0x3f87fb56,0x3eb3e2ee,2
+np.float32,0x3fed17a2,0x3f9d12b4,2
+np.float32,0x7f5ea903,0x42b28d8c,2
+np.float32,0x3f967f82,0x3f15a4ab,2
+np.float32,0x7d3b540c,0x42aca984,2
+np.float32,0x7f56711a,0x42b27a4a,2
+np.float32,0x7f122223,0x42b1b5ee,2
+np.float32,0x3fd6fa34,0x3f8dd919,2
+np.float32,0x3fadd62e,0x3f52a7b3,2
+np.float32,0x3fb7bf0c,0x3f67015f,2
+np.float32,0x7edf4ba7,0x42b12c1d,2
+np.float32,0x7e33cc65,0x42af5a4b,2
+np.float32,0x3fa6be17,0x3f427831,2
+np.float32,0x3fa07aa8,0x3f32b7d4,2
+np.float32,0x3fa4a3af,0x3f3d5a01,2
+np.float32,0x3fdbb267,0x3f9149a8,2
+np.float32,0x7ed45e25,0x42b1126c,2
+np.float32,0x3fe3f432,0x3f970ba6,2
+np.float32,0x7f752080,0x42b2bec3,2
+np.float32,0x3f872747,0x3eaa62ea,2
+np.float32,0x7e52175d,0x42afaa03,2
+np.float32,0x3fdc766c,0x3f91d5ce,2
+np.float32,0x7ecd6841,0x42b1015c,2
+np.float32,0x7f3d6c40,0x42b23ac6,2
+np.float32,0x3fb80c14,0x3f6796b9,2
+np.float32,0x3ff6ad56,0x3fa30d68,2
+np.float32,0x3fda44c3,0x3f90423e,2
+np.float32,0x3fdcba0c,0x3f9205fc,2
+np.float32,0x7e14a720,0x42aef8e6,2
+np.float32,0x3fe9e489,0x3f9b0047,2
+np.float32,0x7e69f933,0x42afe123,2
+np.float32,0x3ff3ee6d,0x3fa15f71,2
+np.float32,0x3f8538cd,0x3e91c1a7,2
+np.float32,0x3fdc3f07,0x3f91ae46,2
+np.float32,0x3fba2ef0,0x3f6bada2,2
+np.float32,0x7da64cd8,0x42adcf71,2
+np.float32,0x3fc34bd2,0x3f7c301d,2
+np.float32,0x3fa273aa,0x3f37d984,2
+np.float32,0x3ff0338c,0x3f9f0c86,2
+np.float32,0x7ed62cef,0x42b116c3,2
+np.float32,0x3f911e7e,0x3f02f7c6,2
+np.float32,0x7c8514c9,0x42aa9792,2
+np.float32,0x3fea2a74,0x3f9b2df5,2
+np.float32,0x3fe036f8,0x3f947a25,2
+np.float32,0x7c5654bf,0x42aa28ad,2
+np.float32,0x3fd9e423,0x3f8ffc32,2
+np.float32,0x7eec0439,0x42b1487b,2
+np.float32,0x3fc580f4,0x3f7ffb62,2
+np.float32,0x3fb0e316,0x3f592bbe,2
+np.float32,0x7c4cfb7d,0x42aa11d8,2
+np.float32,0x3faf9704,0x3f566e00,2
+np.float32,0x3fa7cf8a,0x3f45023d,2
+np.float32,0x7f7b724d,0x42b2cbcc,2
+np.float32,0x7f05bfe3,0x42b18897,2
+np.float32,0x3f90bde3,0x3f018bf3,2
+np.float32,0x7c565479,0x42aa28ad,2
+np.float32,0x3f94b517,0x3f0fb8e5,2
+np.float32,0x3fd6aadd,0x3f8d9e3c,2
+np.float32,0x7f09b37c,0x42b1977f,2
+np.float32,0x7f2b45ea,0x42b20734,2
+np.float32,0x3ff1d15e,0x3fa00fe9,2
+np.float32,0x3f99bce6,0x3f1fbd6c,2
+np.float32,0x7ecd1f76,0x42b100a7,2
+np.float32,0x7f443e2b,0x42b24ce2,2
+np.float32,0x7da7d6a5,0x42add428,2
+np.float32,0x7ebe0193,0x42b0d975,2
+np.float32,0x7ee13c43,0x42b1308b,2
+np.float32,0x3f8adf1b,0x3ed18e0c,2
+np.float32,0x7f76ce65,0x42b2c242,2
+np.float32,0x7e34f43d,0x42af5d92,2
+np.float32,0x7f306b76,0x42b2165d,2
+np.float32,0x7e1fd07f,0x42af1df7,2
+np.float32,0x3fab9a41,0x3f4db909,2
+np.float32,0x3fc23d1a,0x3f7a5803,2
+np.float32,0x3f8b7403,0x3ed70245,2
+np.float32,0x3f8c4dd6,0x3edebbae,2
+np.float32,0x3fe5f411,0x3f9864cd,2
+np.float32,0x3f88128b,0x3eb4e508,2
+np.float32,0x3fcb09de,0x3f84976f,2
+np.float32,0x7f32f2f5,0x42b21da6,2
+np.float32,0x3fe75610,0x3f9950f6,2
+np.float32,0x3f993edf,0x3f1e408d,2
+np.float32,0x3fc4a9d7,0x3f7e8be9,2
+np.float32,0x7f74551a,0x42b2bd1a,2
+np.float32,0x7de87129,0x42ae7ae2,2
+np.float32,0x7f18bbbd,0x42b1cc8c,2
+np.float32,0x7e7e1dd4,0x42b00b6c,2
+np.float32,0x3ff6e55b,0x3fa32f64,2
+np.float32,0x3fa634c8,0x3f412df3,2
+np.float32,0x3fd0fb7c,0x3f894e49,2
+np.float32,0x3ff4f6a6,0x3fa201d7,2
+np.float32,0x7f69d418,0x42b2a69a,2
+np.float32,0x7cb9632d,0x42ab414a,2
+np.float32,0x3fc57d36,0x3f7ff503,2
+np.float32,0x7e9e2ed7,0x42b07b9b,2
+np.float32,0x7f2e6868,0x42b2107d,2
+np.float32,0x3fa3169a,0x3f39785d,2
+np.float32,0x7f03cde0,0x42b18117,2
+np.float32,0x7f6d75d2,0x42b2ae7f,2
+np.float32,0x3ff483f2,0x3fa1bb75,2
+np.float32,0x7f1b39f7,0x42b1d4d6,2
+np.float32,0x3f8c7a7d,0x3ee0481e,2
+np.float32,0x3f989095,0x3f1c2b19,2
+np.float32,0x3fa4cbfd,0x3f3dbd87,2
+np.float32,0x7f75b00f,0x42b2bfef,2
+np.float32,0x3f940724,0x3f0d6756,2
+np.float32,0x7f5e5a1a,0x42b28cd6,2
+np.float32,0x800000,0xffc00000,2
+np.float32,0x7edd1d29,0x42b12716,2
+np.float32,0x3fa3e9e4,0x3f3b8c16,2
+np.float32,0x7e46d70e,0x42af8dd5,2
+np.float32,0x3f824745,0x3e40ec1e,2
+np.float32,0x3fd67623,0x3f8d770a,2
+np.float32,0x3fe9a6f3,0x3f9ad7fa,2
+np.float32,0x3fdda67c,0x3f92adc1,2
+np.float32,0x7ccb6c9a,0x42ab70d4,2
+np.float32,0x3ffd364a,0x3fa6f2fe,2
+np.float32,0x7e02424c,0x42aeb545,2
+np.float32,0x3fb6d2f2,0x3f6534a1,2
+np.float32,0x3fe1fe26,0x3f95b4cc,2
+np.float32,0x7e93ac57,0x42b05867,2
+np.float32,0x7f7b3433,0x42b2cb4d,2
+np.float32,0x3fb76803,0x3f66580d,2
+np.float32,0x3f9af881,0x3f23661b,2
+np.float32,0x3fd58062,0x3f8cbf98,2
+np.float32,0x80000000,0xffc00000,2
+np.float32,0x7f1af8f4,0x42b1d3ff,2
+np.float32,0x3fe66bba,0x3f98b4dc,2
+np.float32,0x7f6bd7bf,0x42b2aaff,2
+np.float32,0x3f84f79a,0x3e8e2e49,2
+np.float32,0x7e475b06,0x42af8f28,2
+np.float32,0x3faff89b,0x3f573d5e,2
+np.float32,0x7de5aa77,0x42ae74bb,2
+np.float32,0x3f8e9e42,0x3ef26cd2,2
+np.float32,0x3fb1cec3,0x3f5b1740,2
+np.float32,0x3f8890d6,0x3eba4821,2
+np.float32,0x3f9b39e9,0x3f242547,2
+np.float32,0x3fc895a4,0x3f829407,2
+np.float32,0x7f77943c,0x42b2c3dc,2
+np.float32,0x7f390d58,0x42b22ed2,2
+np.float32,0x3fe7e160,0x3f99ad58,2
+np.float32,0x3f93d2a0,0x3f0cb205,2
+np.float32,0x7f29499b,0x42b2013c,2
+np.float32,0x3f8c11b2,0x3edca10f,2
+np.float32,0x7e898ef8,0x42b03413,2
+np.float32,0x3fdff942,0x3f944f34,2
+np.float32,0x7f3d602f,0x42b23aa5,2
+np.float32,0x3f8a50f3,0x3ecc345b,2
+np.float32,0x3fa1f86d,0x3f369ce4,2
+np.float32,0x3f97ad95,0x3f19681d,2
+np.float32,0x3ffad1e0,0x3fa589e5,2
+np.float32,0x3fa70590,0x3f432311,2
+np.float32,0x7e6840cb,0x42afdd5c,2
+np.float32,0x3fd4036d,0x3f8ba0aa,2
+np.float32,0x7f7cc953,0x42b2ce84,2
+np.float32,0x7f228e1e,0x42b1ec74,2
+np.float32,0x7e37a866,0x42af652a,2
+np.float32,0x3fda22d0,0x3f9029a7,2
+np.float32,0x7f736bff,0x42b2bb31,2
+np.float32,0x3f9833b6,0x3f1b0b8e,2
+np.float32,0x7f466001,0x42b2526a,2
+np.float32,0xff7fffff,0xffc00000,2
+np.float32,0x7dd62bcd,0x42ae50f8,2
+np.float32,0x7f1d2bfe,0x42b1db36,2
+np.float32,0x7ecffe9e,0x42b107c5,2
+np.float32,0x7ebefe0a,0x42b0dc1b,2
+np.float32,0x7f45c63d,0x42b250dd,2
+np.float32,0x7f601af0,0x42b290db,2
+np.float32,0x3fcbb88a,0x3f8524e5,2
+np.float32,0x7ede55ff,0x42b129e8,2
+np.float32,0x7ea5dd5a,0x42b093e2,2
+np.float32,0x3ff53857,0x3fa22a12,2
+np.float32,0x3f8dbd6a,0x3eeb28a4,2
+np.float32,0x3fd1b467,0x3f89dd2c,2
+np.float32,0x3fe0423f,0x3f9481fc,2
+np.float32,0x3f84b421,0x3e8a6174,2
+np.float32,0x7f4efc97,0x42b2682c,2
+np.float32,0x7f601b33,0x42b290dc,2
+np.float32,0x3f94f240,0x3f108719,2
+np.float32,0x7decd251,0x42ae8471,2
+np.float32,0x3fdc457c,0x3f91b2e2,2
+np.float32,0x3f92a966,0x3f089c5a,2
+np.float32,0x3fc9732f,0x3f834afc,2
+np.float32,0x3f97948f,0x3f19194e,2
+np.float32,0x7f0824a1,0x42b191ac,2
+np.float32,0x7f0365a5,0x42b17f81,2
+np.float32,0x3f800000,0x0,2
+np.float32,0x7f0054c6,0x42b1736b,2
+np.float32,0x3fe86544,0x3f9a0484,2
+np.float32,0x7e95f844,0x42b0604e,2
+np.float32,0x3fce8602,0x3f8761e2,2
+np.float32,0x3fc726c8,0x3f81621d,2
+np.float32,0x3fcf6b03,0x3f88161b,2
+np.float32,0x3fceb843,0x3f87898a,2
+np.float32,0x3fe2f8b2,0x3f966071,2
+np.float32,0x7f3c8e7f,0x42b2386d,2
+np.float32,0x3fcee13a,0x3f87a9d2,2
+np.float32,0x3fc4df27,0x3f7ee73c,2
+np.float32,0x3ffde486,0x3fa758e3,2
+np.float32,0x3fa91be0,0x3f480b17,2
+np.float32,0x7f2a5a7d,0x42b20472,2
+np.float32,0x7e278d80,0x42af362d,2
+np.float32,0x3f96d091,0x3f16a9d5,2
+np.float32,0x7e925225,0x42b053b2,2
+np.float32,0x7f7ef83a,0x42b2d2ec,2
+np.float32,0x7eb4923a,0x42b0bf61,2
+np.float32,0x7e98bf19,0x42b069b3,2
+np.float32,0x3fac93a2,0x3f4fe410,2
+np.float32,0x7f46389c,0x42b25205,2
+np.float32,0x3f9fd447,0x3f30fd54,2
+np.float32,0x3fef42d4,0x3f9e7483,2
+np.float32,0x7f482174,0x42b256ed,2
+np.float32,0x3f97aedb,0x3f196c1e,2
+np.float32,0x7f764edd,0x42b2c13a,2
+np.float32,0x3f9117b5,0x3f02de5c,2
+np.float32,0x3fc7984e,0x3f81c12d,2
+np.float64,0x3ff1e2cb7463c597,0x3fdec6caf39e0c0e,2
+np.float64,0x3ffe4f89789c9f13,0x3ff40f4b1da0f3e9,2
+np.float64,0x7f6a5c9ac034b935,0x408605e51703c145,2
+np.float64,0x7fdcb6ece3b96dd9,0x40862d6521e16d60,2
+np.float64,0x3ff6563e182cac7c,0x3feb9d8210f3fa88,2
+np.float64,0x7fde32025f3c6404,0x40862dcc1d1a9b7f,2
+np.float64,0x7fd755ed35aeabd9,0x40862bbc5522b779,2
+np.float64,0x3ff5c81f4bcb903e,0x3fea71f10b954ea3,2
+np.float64,0x3fffe805d35fd00c,0x3ff50463a1ba2938,2
+np.float64,0x7fd045a1c1a08b43,0x408628d9f431f2f5,2
+np.float64,0x3ff49f7dd9893efc,0x3fe7c6736e17ea8e,2
+np.float64,0x7fccfbc1fd39f783,0x408627eca79acf51,2
+np.float64,0x3ff1af0a00035e14,0x3fdd1c0e7d5706ea,2
+np.float64,0x7fe7bd17162f7a2d,0x4086316af683502b,2
+np.float64,0x3ff0941b8d012837,0x3fd128d274065ac0,2
+np.float64,0x3ffa0c5d98b418bb,0x3ff11af9c8edd17f,2
+np.float64,0x3ffad9733355b2e6,0x3ff1b6d1307acb42,2
+np.float64,0x3ffabb2a33d57654,0x3ff1a0442b034e50,2
+np.float64,0x3ff36118b0c6c231,0x3fe472b7dfb23516,2
+np.float64,0x3ff2441d3664883a,0x3fe0d61145608f0c,2
+np.float64,0x7fe039862d20730b,0x40862e5f8ed752d3,2
+np.float64,0x7fb1dde24023bbc4,0x40861e824cdb0664,2
+np.float64,0x7face6335839cc66,0x40861ccf90a26e16,2
+np.float64,0x3ffb5d0e1af6ba1c,0x3ff2170f6f42fafe,2
+np.float64,0x3ff5c2c6a50b858d,0x3fea665aabf04407,2
+np.float64,0x3ffabb409db57681,0x3ff1a054ea32bfc3,2
+np.float64,0x3ff1e054e983c0aa,0x3fdeb30c17286cb6,2
+np.float64,0x7fe467f73268cfed,0x4086303529e52e9b,2
+np.float64,0x7fe0e86bf961d0d7,0x40862eb40788b04a,2
+np.float64,0x3ffb743542f6e86a,0x3ff227b4ea5acee0,2
+np.float64,0x3ff2de6826e5bcd0,0x3fe2e31fcde0a96c,2
+np.float64,0x7fd6b27ccfad64f9,0x40862b8385697c31,2
+np.float64,0x7fe0918e8d21231c,0x40862e8a82d9517a,2
+np.float64,0x7fd0ca0395a19406,0x4086291a0696ed33,2
+np.float64,0x3ffb042496960849,0x3ff1d658c928abfc,2
+np.float64,0x3ffcd0409799a081,0x3ff31877df0cb245,2
+np.float64,0x7fe429bd06685379,0x4086301c9f259934,2
+np.float64,0x3ff933076092660f,0x3ff06d2e5f4d9ab7,2
+np.float64,0x7feaefcb28f5df95,0x4086326dccf88e6f,2
+np.float64,0x7fb5f2c1f82be583,0x40862027ac02a39d,2
+np.float64,0x3ffb5d9e3bd6bb3c,0x3ff21777501d097e,2
+np.float64,0x10000000000000,0xfff8000000000000,2
+np.float64,0x3ff70361596e06c3,0x3fecf675ceda7e19,2
+np.float64,0x3ff71a21b5ee3444,0x3fed224fa048d9a9,2
+np.float64,0x3ffb102b86762057,0x3ff1df2cc9390518,2
+np.float64,0x7feaaeb35c355d66,0x4086325a60704a90,2
+np.float64,0x7fd9a3d0a93347a0,0x40862c7d300fc076,2
+np.float64,0x7fabcf159c379e2a,0x40861c80cdbbff27,2
+np.float64,0x7fd1c066ec2380cd,0x4086298c3006fee6,2
+np.float64,0x3ff3d5ae2d67ab5c,0x3fe5bc16447428db,2
+np.float64,0x3ff4b76add696ed6,0x3fe800f5bbf21376,2
+np.float64,0x3ff60d89ee0c1b14,0x3feb063fdebe1a68,2
+np.float64,0x7f1d2648003a4c8f,0x4085eaf9238af95a,2
+np.float64,0x7fe8b45f6df168be,0x408631bca5abf6d6,2
+np.float64,0x7fe9ea5308f3d4a5,0x4086321ea2bd3af9,2
+np.float64,0x7fcb6ba5a636d74a,0x4086277b208075ed,2
+np.float64,0x3ff621cfd74c43a0,0x3feb30d59baf5919,2
+np.float64,0x3ff7bc8ca0af7919,0x3fee524da8032896,2
+np.float64,0x7fda22dd0c3445b9,0x40862ca47326d063,2
+np.float64,0x7fd02ed4b2a05da8,0x408628ceb6919421,2
+np.float64,0x3ffe64309fdcc861,0x3ff41c1b18940709,2
+np.float64,0x3ffee4042abdc808,0x3ff46a6005bccb41,2
+np.float64,0x3ff078145b00f029,0x3fceeb3d6bfae0eb,2
+np.float64,0x7fda20fd20b441f9,0x40862ca3e03b990b,2
+np.float64,0x3ffa9e9e9af53d3d,0x3ff18ade3cbee789,2
+np.float64,0x3ff0a1062501420c,0x3fd1e32de6d18c0d,2
+np.float64,0x3ff3bdf118477be2,0x3fe57ad89b7fdf8b,2
+np.float64,0x3ff101c0d5c20382,0x3fd6965d3539be47,2
+np.float64,0x7feba3b53b774769,0x408632a28c7aca4d,2
+np.float64,0x3ff598db5d4b31b7,0x3fea0aa65c0b421a,2
+np.float64,0x3ff5fdfbb72bfbf8,0x3feae55accde4a5e,2
+np.float64,0x7fe5bae53aab75c9,0x408630b5e7a5b92a,2
+np.float64,0x3ff8f668afd1ecd2,0x3ff03af686666c9c,2
+np.float64,0x3ff5ba72dd2b74e6,0x3fea5441f223c093,2
+np.float64,0x3ff8498147109302,0x3fef4e45d501601d,2
+np.float64,0x7feddcfa5efbb9f4,0x4086334106a6e76b,2
+np.float64,0x7fd1a30200234603,0x4086297ee5cc562c,2
+np.float64,0x3ffffa8ee07ff51e,0x3ff50f1dc46f1303,2
+np.float64,0x7fef7ed00ebefd9f,0x408633ae01dabe52,2
+np.float64,0x3ffb6e062276dc0c,0x3ff22344c58c2016,2
+np.float64,0x7fcf2b59943e56b2,0x4086288190dd5eeb,2
+np.float64,0x3ffa589f9254b13f,0x3ff155cc081eee0b,2
+np.float64,0x3ff05415ca60a82c,0x3fc9e45565baef0a,2
+np.float64,0x7feb34bed576697d,0x408632822d5a178c,2
+np.float64,0x3ff3993845c73270,0x3fe51423baf246c3,2
+np.float64,0x3ff88367aaf106d0,0x3fefb2d9ca9f1192,2
+np.float64,0x7fef364304fe6c85,0x4086339b7ed82997,2
+np.float64,0x7fcba2c317374585,0x4086278b24e42934,2
+np.float64,0x3ff1aef885e35df1,0x3fdd1b79f55b20c0,2
+np.float64,0x7fe19367886326ce,0x40862f035f867445,2
+np.float64,0x3ff3c8295e279053,0x3fe5970aa670d32e,2
+np.float64,0x3ff6edda164ddbb4,0x3feccca9eb59d6b9,2
+np.float64,0x7fdeaea940bd5d52,0x40862dece02d151b,2
+np.float64,0x7fea9d6324353ac5,0x408632552ddf0d4f,2
+np.float64,0x7fe60e39e66c1c73,0x408630d45b1ad0c4,2
+np.float64,0x7fde06325abc0c64,0x40862dc07910038c,2
+np.float64,0x7f9ec89d303d9139,0x408617c55ea4c576,2
+np.float64,0x3ff9801930530032,0x3ff0abe5be046051,2
+np.float64,0x3ff4d5859689ab0b,0x3fe849a7f7a19fa3,2
+np.float64,0x3ff38afbc48715f8,0x3fe4ebb7710cbab9,2
+np.float64,0x3ffd88a0e77b1142,0x3ff3916964407e21,2
+np.float64,0x1,0xfff8000000000000,2
+np.float64,0x3ff5db59e58bb6b4,0x3fea9b6b5ccc116f,2
+np.float64,0x3ffd4b05b15a960c,0x3ff369792f661a90,2
+np.float64,0x7fdcebc4fb39d789,0x40862d73cd623378,2
+np.float64,0x3ff5b56f944b6adf,0x3fea4955d6b06ca3,2
+np.float64,0x7fd4e4abf2a9c957,0x40862ad9e9da3c61,2
+np.float64,0x7fe08e0d6aa11c1a,0x40862e88d17ef277,2
+np.float64,0x3ff0dfc97da1bf93,0x3fd50f9004136d8f,2
+np.float64,0x7fdec38eaebd871c,0x40862df2511e26b4,2
+np.float64,0x7ff8000000000000,0x7ff8000000000000,2
+np.float64,0x3ff21865504430cb,0x3fe033fe3cf3947a,2
+np.float64,0x7fdc139708b8272d,0x40862d371cfbad03,2
+np.float64,0x7fe1fe3be3a3fc77,0x40862f336e3ba63a,2
+np.float64,0x7fd9fa2493b3f448,0x40862c97f2960be9,2
+np.float64,0x3ff0a027db414050,0x3fd1d6e54a707c87,2
+np.float64,0x3ff568b16f4ad163,0x3fe99f5c6d7b6e18,2
+np.float64,0x3ffe2f82877c5f05,0x3ff3fb54bd0da753,2
+np.float64,0x7fbaf5778435eaee,0x408621ccc9e2c1be,2
+np.float64,0x7fc5aaf8362b55ef,0x40862598e7072a49,2
+np.float64,0x7fe0ebfdd4a1d7fb,0x40862eb5b7bf99d5,2
+np.float64,0x7fd8efeb5931dfd6,0x40862c444636f408,2
+np.float64,0x3ff361a308c6c346,0x3fe4744cae63e6df,2
+np.float64,0x7fef287d39be50f9,0x40863397f65c807e,2
+np.float64,0x7fe72c4a14ae5893,0x4086313992e52082,2
+np.float64,0x3ffd1be44cba37c8,0x3ff34a9a45239eb9,2
+np.float64,0x3ff50369c18a06d4,0x3fe8b69319f091f1,2
+np.float64,0x3ffb333c25766678,0x3ff1f8c78eeb28f1,2
+np.float64,0x7fe12050416240a0,0x40862ece4e2f2f24,2
+np.float64,0x7fe348f5526691ea,0x40862fc16fbe7b6c,2
+np.float64,0x3ff343cc4d068799,0x3fe41c2a30cab7d2,2
+np.float64,0x7fd1b0daaa2361b4,0x408629852b3104ff,2
+np.float64,0x3ff6a41f37ad483e,0x3fec3b36ee6c6d4a,2
+np.float64,0x3ffad9439435b287,0x3ff1b6add9a1b3d7,2
+np.float64,0x7fbeb9a2f23d7345,0x408622d89ac1eaba,2
+np.float64,0x3ffab3d39fb567a7,0x3ff19ac75b4427f3,2
+np.float64,0x3ff890003ed12000,0x3fefc8844471c6ad,2
+np.float64,0x3ffc9f595e593eb2,0x3ff2f7a8699f06d8,2
+np.float64,0x7fe2224ef6e4449d,0x40862f43684a154a,2
+np.float64,0x3ffa67ba08d4cf74,0x3ff161525778df99,2
+np.float64,0x7fe87e24b570fc48,0x408631ab02b159fb,2
+np.float64,0x7fd6e99be92dd337,0x40862b96dba73685,2
+np.float64,0x7fe90f39fdf21e73,0x408631d9dbd36c1e,2
+np.float64,0x3ffb7806abd6f00e,0x3ff22a719b0f4c46,2
+np.float64,0x3ffa511ba3d4a238,0x3ff1500c124f6e17,2
+np.float64,0x3ff5d7a569abaf4b,0x3fea937391c280e8,2
+np.float64,0x7fc4279d20284f39,0x40862504a5cdcb96,2
+np.float64,0x3ffe8791b1fd0f24,0x3ff431f1ed7eaba0,2
+np.float64,0x7fe3b2f5276765e9,0x40862fecf15e2535,2
+np.float64,0x7feeab0e7abd561c,0x408633778044cfbc,2
+np.float64,0x7fdba88531375109,0x40862d1860306d7a,2
+np.float64,0x7fe7b19b3def6335,0x4086316716d6890b,2
+np.float64,0x3ff9e9437413d287,0x3ff0ff89431c748c,2
+np.float64,0x3ff960716a52c0e3,0x3ff092498028f802,2
+np.float64,0x3ff271bf56a4e37f,0x3fe1786fc8dd775d,2
+np.float64,0x3fff2a6578be54cb,0x3ff494bbe303eeb5,2
+np.float64,0x3ffd842eb5fb085e,0x3ff38e8b7ba42bc5,2
+np.float64,0x3ff91600e5d22c02,0x3ff0553c6a6b3d93,2
+np.float64,0x3ff9153f45f22a7e,0x3ff0549c0eaecf95,2
+np.float64,0x7fe0ab319da15662,0x40862e96da3b19f9,2
+np.float64,0x3ff06acd1f60d59a,0x3fcd2aca543d2772,2
+np.float64,0x3ffb3e7a54d67cf4,0x3ff200f288cd391b,2
+np.float64,0x3ffd01356f1a026b,0x3ff339003462a56c,2
+np.float64,0x3ffacd35def59a6c,0x3ff1adb8d32b3ec0,2
+np.float64,0x3ff6f953264df2a6,0x3fece2f992948d6e,2
+np.float64,0x3ff0fa91f5a1f524,0x3fd64609a28f1590,2
+np.float64,0x7fd1b7610ca36ec1,0x408629881e03dc7d,2
+np.float64,0x3ff4317fb7c86300,0x3fe6b086ed265887,2
+np.float64,0x3ff3856198070ac3,0x3fe4dbb6bc88b9e3,2
+np.float64,0x7fed7fc4573aff88,0x40863327e7013a81,2
+np.float64,0x3ffe53cbbf5ca798,0x3ff411f07a29b1f4,2
+np.float64,0x3ff092195b012433,0x3fd10b1c0b4b14fe,2
+np.float64,0x3ff1a3171163462e,0x3fdcb5c301d5d40d,2
+np.float64,0x3ffa1401f1742804,0x3ff120eb319e9faa,2
+np.float64,0x7fd352f6f426a5ed,0x40862a3a048feb6d,2
+np.float64,0x7fd4ee246fa9dc48,0x40862add895d808f,2
+np.float64,0x3ff0675cfa00ceba,0x3fccb2222c5493ca,2
+np.float64,0x3ffe5cb38f3cb967,0x3ff417773483d161,2
+np.float64,0x7fe11469ea2228d3,0x40862ec8bd3e497f,2
+np.float64,0x3fff13cba67e2798,0x3ff4872fe2c26104,2
+np.float64,0x3ffb73d3d316e7a8,0x3ff2276f08612ea2,2
+np.float64,0x7febfb70f237f6e1,0x408632bbc9450721,2
+np.float64,0x3ff84a0d87b0941b,0x3fef4f3b707e3145,2
+np.float64,0x7fd71fd5082e3fa9,0x40862ba9b4091172,2
+np.float64,0x3ff560737d8ac0e7,0x3fe98cc9c9ba2f61,2
+np.float64,0x3ff46a266ae8d44d,0x3fe74190e5234822,2
+np.float64,0x7fe8cc9225719923,0x408631c477db9708,2
+np.float64,0x3ff871de5930e3bc,0x3fef948f7d00fbef,2
+np.float64,0x3ffd0bc7895a178f,0x3ff33ffc18357721,2
+np.float64,0x3ff66099f9ccc134,0x3febb2bc775b4720,2
+np.float64,0x7fe91f1be9723e37,0x408631deec3a5c9e,2
+np.float64,0x7fd60462f12c08c5,0x40862b4537e1c1c6,2
+np.float64,0x3ff053100ba0a620,0x3fc9bc0c21e2284f,2
+np.float64,0x7fd864c611b0c98b,0x40862c1724506255,2
+np.float64,0x7fd191decb2323bd,0x408629771bfb68cc,2
+np.float64,0x3ff792a1656f2543,0x3fee054f2e135fcf,2
+np.float64,0x7fd03625cea06c4b,0x408628d253b840e3,2
+np.float64,0x7fc3967716272ced,0x408624ca35451042,2
+np.float64,0x7fe6636cb32cc6d8,0x408630f3073a22a7,2
+np.float64,0x3ffc2d3976585a73,0x3ff2a9d4c0dae607,2
+np.float64,0x3fffd10ee79fa21e,0x3ff4f70db69888be,2
+np.float64,0x3ff1d4fcae23a9f9,0x3fde57675007b23c,2
+np.float64,0x3ffa5da19e14bb43,0x3ff1599f74d1c113,2
+np.float64,0x3ff7f4eb0d6fe9d6,0x3feeb85189659e99,2
+np.float64,0x7fbcca44d8399489,0x408622536234f7c1,2
+np.float64,0x7fef5f97ec3ebf2f,0x408633a60fdde0d7,2
+np.float64,0x7fde4a66da3c94cd,0x40862dd290ebc184,2
+np.float64,0x3ff072957a40e52b,0x3fce34d913d87613,2
+np.float64,0x3ff2bc4c9dc57899,0x3fe27497e6ebe27d,2
+np.float64,0x7fd7d152b4afa2a4,0x40862be63469eecd,2
+np.float64,0x3ff957d768f2afaf,0x3ff08b4ad8062a73,2
+np.float64,0x7fe4bc5f45a978be,0x40863055fd66e4eb,2
+np.float64,0x7fc90de345321bc6,0x408626c24ce7e370,2
+np.float64,0x3ff2d7a37d85af47,0x3fe2cd6a40b544a0,2
+np.float64,0x7fe536ea1f6a6dd3,0x40863084bade76a3,2
+np.float64,0x3fff970c9cdf2e19,0x3ff4d524572356dd,2
+np.float64,0x3ffe173ae63c2e76,0x3ff3ec1ee35ad28c,2
+np.float64,0x3ff714025cce2805,0x3fed168aedff4a2b,2
+np.float64,0x7fce7b414c3cf682,0x40862853dcdd19d4,2
+np.float64,0x3ff019623f2032c4,0x3fbc7c602df0bbaf,2
+np.float64,0x3ff72f57fd0e5eb0,0x3fed4ae75f697432,2
+np.float64,0x3ff283778e8506ef,0x3fe1b5c5725b0dfd,2
+np.float64,0x3ff685a29aed0b45,0x3febfdfdedd581e2,2
+np.float64,0x3ff942d24fb285a4,0x3ff07a224c3ecfaf,2
+np.float64,0x3ff2e4a9f465c954,0x3fe2f71905399e8f,2
+np.float64,0x7fdfa1c7fa3f438f,0x40862e2b4e06f098,2
+np.float64,0x3ff49b59c26936b4,0x3fe7bc41c8c1e59d,2
+np.float64,0x3ff2102d3704205a,0x3fe014bf7e28924e,2
+np.float64,0x3ff88de3b8311bc8,0x3fefc4e3e0a15a89,2
+np.float64,0x7fea5ba25374b744,0x40863241519c9b66,2
+np.float64,0x3fffe5df637fcbbf,0x3ff5032488f570f9,2
+np.float64,0x7fe67cfefe6cf9fd,0x408630fc25333cb4,2
+np.float64,0x3ff090bf2b01217e,0x3fd0f6fcf1092b4a,2
+np.float64,0x7fecd75bc5f9aeb7,0x408632f9b6c2e013,2
+np.float64,0x7fe15df38c62bbe6,0x40862eeae5ac944b,2
+np.float64,0x3ff4757875a8eaf1,0x3fe75e0eafbe28ce,2
+np.float64,0x7fecca8a51b99514,0x408632f627c23923,2
+np.float64,0x3ff91ca529d2394a,0x3ff05abb327fd1ca,2
+np.float64,0x3ffb962993b72c53,0x3ff23ff831717579,2
+np.float64,0x3ffd548a2c7aa914,0x3ff36fac7f56d716,2
+np.float64,0x7fbafb5cb035f6b8,0x408621ce898a02fb,2
+np.float64,0x3ff1d86daca3b0db,0x3fde73536c29218c,2
+np.float64,0x7fa8d0f8f431a1f1,0x40861b97a03c3a18,2
+np.float64,0x3ff44f1067489e21,0x3fe6fcbd8144ab2a,2
+np.float64,0x7fec062b07380c55,0x408632bed9c6ce85,2
+np.float64,0x3ff7e11e0fcfc23c,0x3fee94ada7efaac4,2
+np.float64,0x7fe77505c1aeea0b,0x4086315287dda0ba,2
+np.float64,0x7fc465af2728cb5d,0x4086251d236107f7,2
+np.float64,0x3ffe811c4a7d0238,0x3ff42df7e8b6cf2d,2
+np.float64,0x7fe05a471260b48d,0x40862e6fa502738b,2
+np.float64,0x7fec32cd9778659a,0x408632cb8d98c5a3,2
+np.float64,0x7fd203a220a40743,0x408629aa43b010c0,2
+np.float64,0x7fed71f7d17ae3ef,0x4086332428207101,2
+np.float64,0x3ff3918999e72313,0x3fe4fe5e8991402f,2
+np.float64,0x3ff3ecae38c7d95c,0x3fe5fa787d887981,2
+np.float64,0x7fd65345b82ca68a,0x40862b61aed8c64e,2
+np.float64,0x3ff1efdd01c3dfba,0x3fdf2eae36139204,2
+np.float64,0x3ffba9344f375268,0x3ff24d7fdcfc313b,2
+np.float64,0x7fd0469b35208d35,0x408628da6ed24bdd,2
+np.float64,0x7fe525782daa4aef,0x4086307e240c8b30,2
+np.float64,0x3ff8e473d371c8e8,0x3ff02beebd4171c7,2
+np.float64,0x3ff59a43898b3487,0x3fea0dc0a6acea0a,2
+np.float64,0x7fef50c7263ea18d,0x408633a247d7cd42,2
+np.float64,0x7fe8b5a301f16b45,0x408631bd0e71c855,2
+np.float64,0x3ff209369de4126d,0x3fdff4264334446b,2
+np.float64,0x3ffbe2ff4437c5fe,0x3ff2763b356814c7,2
+np.float64,0x3ff55938156ab270,0x3fe97c70514f91bf,2
+np.float64,0x3fff5d8bf81ebb18,0x3ff4b333b230672a,2
+np.float64,0x3ff16a317bc2d463,0x3fdab84e7faa468f,2
+np.float64,0x3ff7e64f8dafcc9f,0x3fee9e0bd57e9566,2
+np.float64,0x7fef4dc065be9b80,0x408633a181e25abb,2
+np.float64,0x3ff64a24a62c9449,0x3feb849ced76437e,2
+np.float64,0x7fc3cb85ef27970b,0x408624dfc39c8f74,2
+np.float64,0x7fec2162a77842c4,0x408632c69b0d43b6,2
+np.float64,0x7feccee6dc399dcd,0x408632f75de98c46,2
+np.float64,0x7faff4f5f43fe9eb,0x40861d9d89be14c9,2
+np.float64,0x7fee82df60fd05be,0x4086336cfdeb7317,2
+np.float64,0x3ffe54588d9ca8b1,0x3ff41247eb2f75ca,2
+np.float64,0x3ffe5615b55cac2c,0x3ff4135c4eb11620,2
+np.float64,0x3ffdaf9a6a1b5f35,0x3ff3aa70e50d1692,2
+np.float64,0x3ff69c045f4d3809,0x3fec2b00734e2cde,2
+np.float64,0x7fd049239aa09246,0x408628dbad6dd995,2
+np.float64,0x3ff2acbe8465597d,0x3fe24138652195e1,2
+np.float64,0x3ffb288302365106,0x3ff1f0f86ca7e5d1,2
+np.float64,0x3fff6fe8d87edfd2,0x3ff4be136acf53c5,2
+np.float64,0x3ffc87c8bfb90f92,0x3ff2e7bbd65867cb,2
+np.float64,0x3ff173327ca2e665,0x3fdb0b945abb00d7,2
+np.float64,0x3ff9a5cf7a134b9f,0x3ff0ca2450f07c78,2
+np.float64,0x7faf782b043ef055,0x40861d7e0e9b35ef,2
+np.float64,0x3ffa0874975410e9,0x3ff117ee3dc8f5ba,2
+np.float64,0x7fc710fc7f2e21f8,0x40862618fed167fb,2
+np.float64,0x7feb73f4c876e7e9,0x40863294ae3ac1eb,2
+np.float64,0x8000000000000000,0xfff8000000000000,2
+np.float64,0x7fb46615c028cc2b,0x40861f91bade4dad,2
+np.float64,0x7fc26b064624d60c,0x4086244c1b76c938,2
+np.float64,0x3ff06ab9fa40d574,0x3fcd282fd971d1b4,2
+np.float64,0x3ff61da7410c3b4e,0x3feb28201031af02,2
+np.float64,0x3ffec7ba1b9d8f74,0x3ff459342511f952,2
+np.float64,0x7ff4000000000000,0x7ffc000000000000,2
+np.float64,0x7fe5d570422baae0,0x408630bfa75008c9,2
+np.float64,0x3ffa895832f512b0,0x3ff17ad41555dccb,2
+np.float64,0x7fd343ac21a68757,0x40862a33ad59947a,2
+np.float64,0x3ffc1eeb37383dd6,0x3ff29ff29e55a006,2
+np.float64,0x7fee3c5c507c78b8,0x4086335a6b768090,2
+np.float64,0x7fe96d774a32daee,0x408631f7b9937e36,2
+np.float64,0x7fb878362430f06b,0x40862106603497b6,2
+np.float64,0x7fec0a79c03814f3,0x408632c01479905e,2
+np.float64,0x3ffa2f143c145e28,0x3ff135e25d902e1a,2
+np.float64,0x3ff14ccff80299a0,0x3fd9a0cd3397b14c,2
+np.float64,0x3ff97980dcb2f302,0x3ff0a6942a8133ab,2
+np.float64,0x3ff872e2d1f0e5c6,0x3fef96526eb2f756,2
+np.float64,0x7fdf1c9b46be3936,0x40862e0957fee329,2
+np.float64,0x7fcab6525d356ca4,0x408627458791f029,2
+np.float64,0x3ff964e74a52c9ce,0x3ff095e8845d523c,2
+np.float64,0x3ffb3aa23c967544,0x3ff1fe282d897c13,2
+np.float64,0x7fdd8a36afbb146c,0x40862d9f2b05f61b,2
+np.float64,0x3ffea39f42fd473e,0x3ff4432a48176399,2
+np.float64,0x7fea614f68b4c29e,0x408632430a750385,2
+np.float64,0x7feeafb86abd5f70,0x40863378b79f70cf,2
+np.float64,0x3ff80bc94eb01792,0x3feee138e9d626bd,2
+np.float64,0x7fcaca74743594e8,0x4086274b8ce4d1e1,2
+np.float64,0x3ff8b14815316290,0x3ff000b3526c8321,2
+np.float64,0x7fc698eb5f2d31d6,0x408625eeec86cd2b,2
+np.float64,0x7fe15429a3e2a852,0x40862ee6621205b8,2
+np.float64,0x7fee37f81b7c6fef,0x4086335941ed80dd,2
+np.float64,0x3ff8097ab3f012f6,0x3feedd1bafc3196e,2
+np.float64,0x7fe7c889ceaf9113,0x4086316ed13f2394,2
+np.float64,0x7fceca94513d9528,0x4086286893a06824,2
+np.float64,0x3ff593a103cb2742,0x3fe9ff1af4f63cc9,2
+np.float64,0x7fee237d24bc46f9,0x40863353d4142c87,2
+np.float64,0x3ffbf71e4777ee3c,0x3ff2844c0ed9f4d9,2
+np.float64,0x3ff490c65c09218d,0x3fe7a2216d9f69fd,2
+np.float64,0x3fff5ceaf1feb9d6,0x3ff4b2d430a90110,2
+np.float64,0x3ff55baecceab75e,0x3fe98203980666c4,2
+np.float64,0x3ff511bc306a2378,0x3fe8d81ce7be7b50,2
+np.float64,0x3ff38f83dcc71f08,0x3fe4f89f130d5f87,2
+np.float64,0x3ff73a3676ee746d,0x3fed5f98a65107ee,2
+np.float64,0x7fc27e50c824fca1,0x408624547828bc49,2
+np.float64,0xfff0000000000000,0xfff8000000000000,2
+np.float64,0x3fff38959ebe712b,0x3ff49d362c7ba16a,2
+np.float64,0x3ffad6d23a75ada4,0x3ff1b4dda6394ed0,2
+np.float64,0x3ffe77c6c2dcef8e,0x3ff4283698835ecb,2
+np.float64,0x3fff5feb413ebfd6,0x3ff4b49bcbdb3aa9,2
+np.float64,0x3ff0d30aa161a615,0x3fd4751bcdd7d727,2
+np.float64,0x3ff51e07e00a3c10,0x3fe8f4bd1408d694,2
+np.float64,0x8010000000000000,0xfff8000000000000,2
+np.float64,0x7fd231d2fe2463a5,0x408629beaceafcba,2
+np.float64,0x3fff6b4aee1ed696,0x3ff4bb58544bf8eb,2
+np.float64,0x3ff91fcd2f323f9a,0x3ff05d56e33db6b3,2
+np.float64,0x3ff3b889ab477113,0x3fe56bdeab74cce5,2
+np.float64,0x3ff99bfe30d337fc,0x3ff0c24bbf265561,2
+np.float64,0x3ffbe9e5eaf7d3cc,0x3ff27b0fe60f827a,2
+np.float64,0x7fd65678e92cacf1,0x40862b62d44fe8b6,2
+np.float64,0x7fd9cc477233988e,0x40862c89c638ee48,2
+np.float64,0x3ffc123c72d82479,0x3ff297294d05cbc0,2
+np.float64,0x3ff58abad58b1576,0x3fe9eb65da2a867a,2
+np.float64,0x7fe534887b2a6910,0x40863083d4ec2877,2
+np.float64,0x7fe1d3dcb123a7b8,0x40862f208116c55e,2
+np.float64,0x7fd4d570dba9aae1,0x40862ad412c413cd,2
+np.float64,0x3fffce7d3fdf9cfa,0x3ff4f58f02451928,2
+np.float64,0x3ffa76901c74ed20,0x3ff16c9a5851539c,2
+np.float64,0x7fdd88ffa23b11fe,0x40862d9ed6c6f426,2
+np.float64,0x3ff09fdbb9e13fb7,0x3fd1d2ae4fcbf713,2
+np.float64,0x7fe64567772c8ace,0x408630e845dbc290,2
+np.float64,0x7fb1a849ba235092,0x40861e6a291535b2,2
+np.float64,0x3ffaddb105f5bb62,0x3ff1b9f68f4c419b,2
+np.float64,0x7fd2fc3d5025f87a,0x40862a15cbc1df75,2
+np.float64,0x7fdea7d872bd4fb0,0x40862deb190b2c50,2
+np.float64,0x7fd50ea97eaa1d52,0x40862ae9edc4c812,2
+np.float64,0x3fff659c245ecb38,0x3ff4b7fb18b31aea,2
+np.float64,0x3ff3f1fbb7c7e3f7,0x3fe608bd9d76268c,2
+np.float64,0x3ff76869d9aed0d4,0x3fedb6c23d3a317b,2
+np.float64,0x7fedd4efe93ba9df,0x4086333edeecaa43,2
+np.float64,0x3ff9a5bd4eb34b7a,0x3ff0ca15d02bc960,2
+np.float64,0x3ffd9359cc5b26b4,0x3ff39850cb1a6b6c,2
+np.float64,0x7fe912d0427225a0,0x408631db00e46272,2
+np.float64,0x3ffb3802fe567006,0x3ff1fc4093646465,2
+np.float64,0x3ff02cc38a205987,0x3fc2e8182802a07b,2
+np.float64,0x3ffda953dd1b52a8,0x3ff3a66c504cf207,2
+np.float64,0x7fe0a487e4a1490f,0x40862e93a6f20152,2
+np.float64,0x7fed265ed1fa4cbd,0x4086330f838ae431,2
+np.float64,0x7fd0000114200001,0x408628b76ec48b5c,2
+np.float64,0x3ff2c262786584c5,0x3fe288860d354b0f,2
+np.float64,0x8000000000000001,0xfff8000000000000,2
+np.float64,0x3ffdae9f075b5d3e,0x3ff3a9d006ae55c1,2
+np.float64,0x3ffb69c72156d38e,0x3ff22037cbb85e5b,2
+np.float64,0x7feeae255f7d5c4a,0x408633784e89bc05,2
+np.float64,0x7feb13927c362724,0x408632786630c55d,2
+np.float64,0x7fef49e072be93c0,0x408633a08451d476,2
+np.float64,0x3fff23d6337e47ac,0x3ff490ceb6e634ae,2
+np.float64,0x3ffba82cf8f7505a,0x3ff24cc51c73234d,2
+np.float64,0x7fe948719ef290e2,0x408631ec0b36476e,2
+np.float64,0x3ff41926c5e8324e,0x3fe670e14bbda8cd,2
+np.float64,0x3ff91f09c1523e14,0x3ff05cb5731878da,2
+np.float64,0x3ff6ae6afccd5cd6,0x3fec4fbeca764086,2
+np.float64,0x3ff927f7e0f24ff0,0x3ff06413eeb8eb1e,2
+np.float64,0x3ff19dd2b9e33ba5,0x3fdc882f97994600,2
+np.float64,0x7fe8e502c5b1ca05,0x408631cc56526fff,2
+np.float64,0x7feb49f70fb693ed,0x4086328868486fcd,2
+np.float64,0x3ffd942d535b285a,0x3ff398d8d89f52ca,2
+np.float64,0x7fc3b9c5c627738b,0x408624d893e692ca,2
+np.float64,0x7fea0780ff340f01,0x408632279fa46704,2
+np.float64,0x7fe4c90066a99200,0x4086305adb47a598,2
+np.float64,0x7fdb209113364121,0x40862cf0ab64fd7d,2
+np.float64,0x3ff38617e5470c30,0x3fe4ddc0413b524f,2
+np.float64,0x7fea1b5b803436b6,0x4086322db767f091,2
+np.float64,0x7fe2004898e40090,0x40862f3457795dc5,2
+np.float64,0x3ff3c4360ac7886c,0x3fe58c29843a4c75,2
+np.float64,0x3ff504bc168a0978,0x3fe8b9ada7f698e6,2
+np.float64,0x3ffd3e936fda7d27,0x3ff3615912c5b4ac,2
+np.float64,0x3ffbdc52fb97b8a6,0x3ff2718dae5f1f2b,2
+np.float64,0x3fffef6d84ffdedb,0x3ff508adbc8556cf,2
+np.float64,0x3ff23b65272476ca,0x3fe0b646ed2579eb,2
+np.float64,0x7fe4633068a8c660,0x408630334a4b7ff7,2
+np.float64,0x3ff769b754aed36f,0x3fedb932af0223f9,2
+np.float64,0x7fe7482d92ee905a,0x408631432de1b057,2
+np.float64,0x3ff5dd682aabbad0,0x3fea9fd5e506a86d,2
+np.float64,0x7fd68399a2ad0732,0x40862b72ed89805d,2
+np.float64,0x3ffad7acc3d5af5a,0x3ff1b57fe632c948,2
+np.float64,0x3ffc68e43698d1c8,0x3ff2d2be6f758761,2
+np.float64,0x3ff4e517fbc9ca30,0x3fe86eddf5e63a58,2
+np.float64,0x3ff34c63c56698c8,0x3fe435b74ccd6a13,2
+np.float64,0x7fea9456c17528ad,0x4086325275237015,2
+np.float64,0x7fee6573f2fccae7,0x4086336543760346,2
+np.float64,0x7fd5496fb9aa92de,0x40862b0023235667,2
+np.float64,0x7ff0000000000000,0x7ff0000000000000,2
+np.float64,0x3ffb70e31256e1c6,0x3ff22552f54b13e0,2
+np.float64,0x3ff66a33988cd467,0x3febc656da46a1ca,2
+np.float64,0x3fff0af2eb1e15e6,0x3ff481dec325f5c8,2
+np.float64,0x3ff6a0233d0d4046,0x3fec33400958eda1,2
+np.float64,0x7fdb11e2d5b623c5,0x40862cec55e405f9,2
+np.float64,0x3ffb8a015ad71402,0x3ff2374d7b563a72,2
+np.float64,0x3ff1807d8ce300fb,0x3fdb849e4bce8335,2
+np.float64,0x3ffefd535e3dfaa6,0x3ff479aaac6ffe79,2
+np.float64,0x3ff701e23a6e03c4,0x3fecf39072d96fc7,2
+np.float64,0x3ff4ac809f895901,0x3fe7e6598f2335a5,2
+np.float64,0x3ff0309f26a0613e,0x3fc3b3f4b2783690,2
+np.float64,0x3ff241dd0ce483ba,0x3fe0cde2cb639144,2
+np.float64,0x3ffabce63fb579cc,0x3ff1a18fe2a2da59,2
+np.float64,0x3ffd84b967db0973,0x3ff38ee4f240645d,2
+np.float64,0x7fc3f88b9a27f116,0x408624f1e10cdf3f,2
+np.float64,0x7fe1d5fd5923abfa,0x40862f2175714a3a,2
+np.float64,0x7fe487b145690f62,0x4086304190700183,2
+np.float64,0x7fe7997feaef32ff,0x4086315eeefdddd2,2
+np.float64,0x3ff8f853b671f0a8,0x3ff03c907353a8da,2
+np.float64,0x7fca4c23b5349846,0x408627257ace5778,2
+np.float64,0x7fe0c9bf3a21937d,0x40862ea576c3ea43,2
+np.float64,0x7fc442b389288566,0x4086250f5f126ec9,2
+np.float64,0x7fc6d382ed2da705,0x40862603900431b0,2
+np.float64,0x7fe40b069068160c,0x4086301066468124,2
+np.float64,0x3ff7f62a146fec54,0x3feeba8dfc4363fe,2
+np.float64,0x3ff721e8e94e43d2,0x3fed313a6755d34f,2
+np.float64,0x7fe579feaf2af3fc,0x4086309ddefb6112,2
+np.float64,0x3ffe2c6bde5c58d8,0x3ff3f9665dc9a16e,2
+np.float64,0x7fcf9998ed3f3331,0x4086289dab274788,2
+np.float64,0x7fdb03af2236075d,0x40862ce82252e490,2
+np.float64,0x7fe72799392e4f31,0x40863137f428ee71,2
+np.float64,0x7f9f2190603e4320,0x408617dc5b3b3c3c,2
+np.float64,0x3ff69c56d52d38ae,0x3fec2ba59fe938b2,2
+np.float64,0x7fdcde27bf39bc4e,0x40862d70086cd06d,2
+np.float64,0x3ff654d6b8eca9ae,0x3feb9aa0107609a6,2
+np.float64,0x7fdf69d967bed3b2,0x40862e1d1c2b94c2,2
+np.float64,0xffefffffffffffff,0xfff8000000000000,2
+np.float64,0x7fedfd073f3bfa0d,0x40863349980c2c8b,2
+np.float64,0x7f7c1856803830ac,0x40860bf312b458c7,2
+np.float64,0x7fe9553f1bb2aa7d,0x408631f0173eadd5,2
+np.float64,0x3ff6e92efc2dd25e,0x3fecc38f98e7e1a7,2
+np.float64,0x7fe9719ac532e335,0x408631f906cd79c3,2
+np.float64,0x3ff60e56ae4c1cad,0x3feb07ef8637ec7e,2
+np.float64,0x3ff0d0803501a100,0x3fd455c0af195a9c,2
+np.float64,0x7fe75248a3eea490,0x40863146a614aec1,2
+np.float64,0x7fdff61ead3fec3c,0x40862e408643d7aa,2
+np.float64,0x7fed4ac7a4fa958e,0x408633197b5cf6ea,2
+np.float64,0x7fe58d44562b1a88,0x408630a5098d1bbc,2
+np.float64,0x7fd89dcdb1b13b9a,0x40862c29c2979288,2
+np.float64,0x3ff205deda240bbe,0x3fdfda67c84fd3a8,2
+np.float64,0x7fdf84c15abf0982,0x40862e23f361923d,2
+np.float64,0x3ffe012b3afc0256,0x3ff3de3dfa5f47ce,2
+np.float64,0x3ffe2f3512dc5e6a,0x3ff3fb245206398e,2
+np.float64,0x7fed6174c2bac2e9,0x4086331faa699617,2
+np.float64,0x3ff1f30f8783e61f,0x3fdf47e06f2c40d1,2
+np.float64,0x3ff590da9eab21b5,0x3fe9f8f7b4baf3c2,2
+np.float64,0x3ffb3ca1eb967944,0x3ff1ff9baf66d704,2
+np.float64,0x7fe50ba9a5aa1752,0x408630745ab7fd3c,2
+np.float64,0x3ff43743a4a86e87,0x3fe6bf7ae80b1dda,2
+np.float64,0x3ff47e1a24e8fc34,0x3fe773acca44c7d6,2
+np.float64,0x3ff589ede9eb13dc,0x3fe9e99f28fab3a4,2
+np.float64,0x3ff72f2cbf8e5e5a,0x3fed4a94e7edbf24,2
+np.float64,0x3ffa4f9bbc549f38,0x3ff14ee60aea45d3,2
+np.float64,0x3ff975dae732ebb6,0x3ff0a3a1fbd7284a,2
+np.float64,0x7fbcf14ee039e29d,0x4086225e33f3793e,2
+np.float64,0x3ff10e027f621c05,0x3fd71cce2452b4e0,2
+np.float64,0x3ff33ea193067d43,0x3fe40cbac4daaddc,2
+np.float64,0x7fbef8f2263df1e3,0x408622e905c8e1b4,2
+np.float64,0x3fff7f5bfe3efeb8,0x3ff4c732e83df253,2
+np.float64,0x3ff5700a6b4ae015,0x3fe9afdd7b8b82b0,2
+np.float64,0x3ffd5099da5aa134,0x3ff36d1bf26e55bf,2
+np.float64,0x3ffed8e0f89db1c2,0x3ff4639ff065107a,2
+np.float64,0x3fff9d0c463f3a18,0x3ff4d8a9f297cf52,2
+np.float64,0x3ff23db5b2e47b6b,0x3fe0bebdd48f961a,2
+np.float64,0x3ff042bff1e08580,0x3fc713bf24cc60ef,2
+np.float64,0x7feb4fe97a769fd2,0x4086328a26675646,2
+np.float64,0x3ffeafbfeedd5f80,0x3ff44a955a553b1c,2
+np.float64,0x3ff83fb524507f6a,0x3fef3d1729ae0976,2
+np.float64,0x3ff1992294433245,0x3fdc5f5ce53dd197,2
+np.float64,0x7fe89fe629b13fcb,0x408631b601a83867,2
+np.float64,0x7fe53e4d74aa7c9a,0x40863087839b52f1,2
+np.float64,0x3ff113713e6226e2,0x3fd757631ca7cd09,2
+np.float64,0x7fd4a0b7a629416e,0x40862abfba27a09b,2
+np.float64,0x3ff184c6e2a3098e,0x3fdbab2e3966ae57,2
+np.float64,0x3ffafbbf77f5f77f,0x3ff1d02bb331d9f9,2
+np.float64,0x3ffc6099a358c134,0x3ff2cd16941613d1,2
+np.float64,0x3ffb7c441ef6f888,0x3ff22d7b12e31432,2
+np.float64,0x3ff625ba5eec4b75,0x3feb39060e55fb79,2
+np.float64,0x7fde879acbbd0f35,0x40862de2aab4d72d,2
+np.float64,0x7f930aed982615da,0x408613edb6df8528,2
+np.float64,0x7fa4b82dac29705a,0x40861a261c0a9aae,2
+np.float64,0x7fced5c16b3dab82,0x4086286b7a73e611,2
+np.float64,0x7fe133749d2266e8,0x40862ed73a41b112,2
+np.float64,0x3ff2d8146ea5b029,0x3fe2ced55dbf997d,2
+np.float64,0x3ff60dac77ac1b59,0x3feb0688b0e54c7b,2
+np.float64,0x3ff275d9b024ebb3,0x3fe186b87258b834,2
+np.float64,0x3ff533e6500a67cd,0x3fe92746c8b50ddd,2
+np.float64,0x7fe370896666e112,0x40862fd1ca144736,2
+np.float64,0x7fee7695357ced29,0x40863369c459420e,2
+np.float64,0x7fd1e0528023c0a4,0x4086299a85caffd0,2
+np.float64,0x7fd05c7b24a0b8f5,0x408628e52824386f,2
+np.float64,0x3ff11dcc3b023b98,0x3fd7c56c8cef1be1,2
+np.float64,0x7fc9d9fae933b3f5,0x408627027404bc5f,2
+np.float64,0x7fe2359981246b32,0x40862f4be675e90d,2
+np.float64,0x3ffb10a949962152,0x3ff1df88f83b8cde,2
+np.float64,0x3ffa65b53654cb6a,0x3ff15fc8956ccc87,2
+np.float64,0x3ff0000000000000,0x0,2
+np.float64,0x7fad97ef703b2fde,0x40861d002f3d02da,2
+np.float64,0x3ff57aaf93aaf55f,0x3fe9c7b01f194edb,2
+np.float64,0x7fe9ecd73f33d9ad,0x4086321f69917205,2
+np.float64,0x3ff0dcb79c61b96f,0x3fd4eac86a7a9c38,2
+np.float64,0x7fee9c12ffbd3825,0x4086337396cd706d,2
+np.float64,0x3ff52c40af4a5881,0x3fe915a8a7de8f00,2
+np.float64,0x3ffbcfff59779ffe,0x3ff268e523fe8dda,2
+np.float64,0x7fe014cb4b602996,0x40862e4d5de42a03,2
+np.float64,0x7fae2370e83c46e1,0x40861d258dd5b3ee,2
+np.float64,0x7fe9e33602f3c66b,0x4086321c704ac2bb,2
+np.float64,0x3ff648acd74c915a,0x3feb8195ca53bcaa,2
+np.float64,0x7fe385f507670be9,0x40862fda95ebaf44,2
+np.float64,0x3ffb0e382c361c70,0x3ff1ddbea963e0a7,2
+np.float64,0x3ff47d6b6ae8fad7,0x3fe771f80ad37cd2,2
+np.float64,0x3ffca7d538f94faa,0x3ff2fd5f62e851ac,2
+np.float64,0x3ff83e949c107d29,0x3fef3b1c5bbac99b,2
+np.float64,0x7fc6fb933a2df725,0x408626118e51a286,2
+np.float64,0x7fe43a1454e87428,0x4086302318512d9b,2
+np.float64,0x7fe51fe32aaa3fc5,0x4086307c07271348,2
+np.float64,0x3ff35e563966bcac,0x3fe46aa2856ef85f,2
+np.float64,0x3ff84dd4e4909baa,0x3fef55d86d1d5c2e,2
+np.float64,0x7febe3d84077c7b0,0x408632b507686f03,2
+np.float64,0x3ff6aca2e32d5946,0x3fec4c32a2368ee3,2
+np.float64,0x7fe7070e3e6e0e1b,0x4086312caddb0454,2
+np.float64,0x7fd3657f2aa6cafd,0x40862a41acf47e70,2
+np.float64,0x3ff61534456c2a68,0x3feb1663900af13b,2
+np.float64,0x3ff8bc556eb178ab,0x3ff00a16b5403f88,2
+np.float64,0x3ffa7782e3f4ef06,0x3ff16d529c94a438,2
+np.float64,0x7fc15785ed22af0b,0x408623d0cd94fb86,2
+np.float64,0x3ff2e3eeb6e5c7dd,0x3fe2f4c4876d3edf,2
+np.float64,0x3ff2e4e17e85c9c3,0x3fe2f7c9e437b22e,2
+np.float64,0x7feb3aaf67f6755e,0x40863283ec4a0d76,2
+np.float64,0x7fe89efcf7313df9,0x408631b5b5e41263,2
+np.float64,0x3ffcc6fad4f98df6,0x3ff31245778dff6d,2
+np.float64,0x3ff356114466ac22,0x3fe45253d040a024,2
+np.float64,0x3ff81c70d2d038e2,0x3feefed71ebac776,2
+np.float64,0x7fdb75c96136eb92,0x40862d09a603f03e,2
+np.float64,0x3ff340f91b8681f2,0x3fe413bb6e6d4a54,2
+np.float64,0x3fff906079df20c1,0x3ff4d13869d16bc7,2
+np.float64,0x3ff226a42d644d48,0x3fe0698d316f1ac0,2
+np.float64,0x3ff948abc3b29158,0x3ff07eeb0b3c81ba,2
+np.float64,0x3ffc25df1fb84bbe,0x3ff2a4c13ad4edad,2
+np.float64,0x7fe07ea3b960fd46,0x40862e815b4cf43d,2
+np.float64,0x3ff497d3dae92fa8,0x3fe7b3917bf10311,2
+np.float64,0x7fea561db1f4ac3a,0x4086323fa4aef2a9,2
+np.float64,0x7fd1b49051236920,0x40862986d8759ce5,2
+np.float64,0x7f7ba3bd6037477a,0x40860bd19997fd90,2
+np.float64,0x3ff01126dd00224e,0x3fb76b67938dfb11,2
+np.float64,0x3ff29e1105053c22,0x3fe2102a4c5fa102,2
+np.float64,0x3ff9de2a6553bc55,0x3ff0f6cfe4dea30e,2
+np.float64,0x7fc558e7d42ab1cf,0x4086257a608fc055,2
+np.float64,0x3ff79830a74f3061,0x3fee0f93db153d65,2
+np.float64,0x7fe2661648e4cc2c,0x40862f6117a71eb2,2
+np.float64,0x3ff140cf4262819e,0x3fd92aefedae1ab4,2
+np.float64,0x3ff5f36251abe6c5,0x3feaced481ceaee3,2
+np.float64,0x7fc80911d5301223,0x4086266d4757f768,2
+np.float64,0x3ff9079a6c320f35,0x3ff04949d21ebe1e,2
+np.float64,0x3ffde8d2e09bd1a6,0x3ff3cedca8a5db5d,2
+np.float64,0x3ffadd1de375ba3c,0x3ff1b989790e8d93,2
+np.float64,0x3ffdbc40ee1b7882,0x3ff3b286b1c7da57,2
+np.float64,0x3ff8ff514771fea2,0x3ff04264add00971,2
+np.float64,0x7fefd7d0e63fafa1,0x408633c47d9f7ae4,2
+np.float64,0x3ffc47798c588ef3,0x3ff2bbe441fa783a,2
+np.float64,0x7fe6ebc55b6dd78a,0x408631232d9abf31,2
+np.float64,0xbff0000000000000,0xfff8000000000000,2
+np.float64,0x7fd378e4afa6f1c8,0x40862a49a8f98cb4,2
+np.float64,0x0,0xfff8000000000000,2
+np.float64,0x3ffe88ed7efd11db,0x3ff432c7ecb95492,2
+np.float64,0x3ff4f5509289eaa1,0x3fe8955a11656323,2
+np.float64,0x7fda255b41344ab6,0x40862ca53676a23e,2
+np.float64,0x3ffebe85b9bd7d0c,0x3ff453992cd55dea,2
+np.float64,0x3ff5d6180b8bac30,0x3fea901c2160c3bc,2
+np.float64,0x3ffcdfb8fcf9bf72,0x3ff322c83b3bc735,2
+np.float64,0x3ff3c91c26679238,0x3fe599a652b7cf59,2
+np.float64,0x7fc389f7a62713ee,0x408624c518edef93,2
+np.float64,0x3ffe1245ba1c248c,0x3ff3e901b2c4a47a,2
+np.float64,0x7fe1e76e95e3cedc,0x40862f29446f9eff,2
+np.float64,0x3ff02ae4f92055ca,0x3fc28221abd63daa,2
+np.float64,0x7fbf648a143ec913,0x40862304a0619d03,2
+np.float64,0x3ff2be7ef8657cfe,0x3fe27bcc6c97522e,2
+np.float64,0x3ffa7595e514eb2c,0x3ff16bdc64249ad1,2
+np.float64,0x3ff4ee130049dc26,0x3fe884354cbad8c9,2
+np.float64,0x3ff19211fc232424,0x3fdc2160bf3eae40,2
+np.float64,0x3ffec215aedd842c,0x3ff455c4cdd50c32,2
+np.float64,0x7fe7cb50ffaf96a1,0x4086316fc06a53af,2
+np.float64,0x3fffa679161f4cf2,0x3ff4de30ba7ac5b8,2
+np.float64,0x7fdcb459763968b2,0x40862d646a21011d,2
+np.float64,0x3ff9f338d6d3e672,0x3ff1075835d8f64e,2
+np.float64,0x3ff8de3319d1bc66,0x3ff026ae858c0458,2
+np.float64,0x7fee0199d33c0333,0x4086334ad03ac683,2
+np.float64,0x3ffc06076c380c0f,0x3ff28eaec3814faa,2
+np.float64,0x3ffe9e2e235d3c5c,0x3ff43fd4d2191a7f,2
+np.float64,0x3ffd93b06adb2761,0x3ff398888239cde8,2
+np.float64,0x7fefe4b71cffc96d,0x408633c7ba971b92,2
+np.float64,0x7fb2940352252806,0x40861ed244bcfed6,2
+np.float64,0x3ffba4647e3748c9,0x3ff24a15f02e11b9,2
+np.float64,0x7fd2d9543725b2a7,0x40862a0708446596,2
+np.float64,0x7fc04997f120932f,0x4086235055d35251,2
+np.float64,0x3ff6d14313ada286,0x3fec94b177f5d3fc,2
+np.float64,0x3ff279fc8684f3f9,0x3fe19511c3e5b9a8,2
+np.float64,0x3ff42f4609085e8c,0x3fe6aabe526ce2bc,2
+np.float64,0x7fc1c6c62a238d8b,0x408624037de7f6ec,2
+np.float64,0x7fe31ff4b8e63fe8,0x40862fb05b40fd16,2
+np.float64,0x7fd2a8825fa55104,0x408629f234d460d6,2
+np.float64,0x3ffe8c1d725d183b,0x3ff434bdc444143f,2
+np.float64,0x3ff0e9dc3e21d3b8,0x3fd58676e2c13fc9,2
+np.float64,0x3ffed03172fda063,0x3ff45e59f7aa6c8b,2
+np.float64,0x7fd74621962e8c42,0x40862bb6e90d66f8,2
+np.float64,0x3ff1faa29663f545,0x3fdf833a2c5efde1,2
+np.float64,0x7fda02834db40506,0x40862c9a860d6747,2
+np.float64,0x7f709b2fc021365f,0x408607be328eb3eb,2
+np.float64,0x7fec0d58aa381ab0,0x408632c0e61a1af6,2
+np.float64,0x3ff524d1720a49a3,0x3fe90479968d40fd,2
+np.float64,0x7fd64cb3b32c9966,0x40862b5f53c4b0b4,2
+np.float64,0x3ff9593e3ed2b27c,0x3ff08c6eea5f6e8b,2
+np.float64,0x3ff7de8b1f6fbd16,0x3fee9007abcfdf7b,2
+np.float64,0x7fe8d816d6b1b02d,0x408631c82e38a894,2
+np.float64,0x7fd726bbe22e4d77,0x40862bac16ee8d52,2
+np.float64,0x7fa70b07d42e160f,0x40861affcc4265e2,2
+np.float64,0x7fe18b4091e31680,0x40862effa8bce66f,2
+np.float64,0x3ff830253010604a,0x3fef21b2eaa75758,2
+np.float64,0x3fffcade407f95bc,0x3ff4f3734b24c419,2
+np.float64,0x3ff8c17cecb182fa,0x3ff00e75152d7bda,2
+np.float64,0x7fdad9b9d035b373,0x40862cdbabb793ba,2
+np.float64,0x3ff9f9e154f3f3c2,0x3ff10c8dfdbd2510,2
+np.float64,0x3ff465e162e8cbc3,0x3fe736c751c75b73,2
+np.float64,0x3ff9b4cd8493699b,0x3ff0d616235544b8,2
+np.float64,0x7fe557c4a56aaf88,0x4086309114ed12d9,2
+np.float64,0x7fe5999133eb3321,0x408630a9991a9b54,2
+np.float64,0x7fe7c9009e2f9200,0x4086316ef9359a47,2
+np.float64,0x3ff8545cabd0a8ba,0x3fef6141f1030c36,2
+np.float64,0x3ffa1f1712943e2e,0x3ff129849d492ce3,2
+np.float64,0x7fea803a14750073,0x4086324c652c276c,2
+np.float64,0x3ff5b6f97fcb6df3,0x3fea4cb0b97b18e9,2
+np.float64,0x7fc2efdfc425dfbf,0x40862485036a5c6e,2
+np.float64,0x7fe2c78e5be58f1c,0x40862f8b0a5e7baf,2
+np.float64,0x7fe80d7fff301aff,0x40863185e234060a,2
+np.float64,0x3ffd895d457b12ba,0x3ff391e2cac7a3f8,2
+np.float64,0x3ff44c9764a8992f,0x3fe6f6690396c232,2
+np.float64,0x3ff731688b8e62d1,0x3fed4ed70fac3839,2
+np.float64,0x3ff060200460c040,0x3fcbad4a07d97f0e,2
+np.float64,0x3ffbd2f70a17a5ee,0x3ff26afb46ade929,2
+np.float64,0x7febe9e841f7d3d0,0x408632b6c465ddd9,2
+np.float64,0x3ff2532f8be4a65f,0x3fe10c6cd8d64cf4,2
+np.float64,0x7fefffffffffffff,0x408633ce8fb9f87e,2
+np.float64,0x3ff3a1ae3a47435c,0x3fe52c00210cc459,2
+np.float64,0x7fe9c34ae6b38695,0x408632128d150149,2
+np.float64,0x3fff311029fe6220,0x3ff498b852f30bff,2
+np.float64,0x3ffd4485a1ba890c,0x3ff3653b6fa701cd,2
+np.float64,0x7fd52718b1aa4e30,0x40862af330d9c68c,2
+np.float64,0x3ff10b695a4216d3,0x3fd7009294e367b7,2
+np.float64,0x3ffdf73de59bee7c,0x3ff3d7fa96d2c1ae,2
+np.float64,0x3ff2f1c75965e38f,0x3fe320aaff3db882,2
+np.float64,0x3ff2a56a5a854ad5,0x3fe228cc4ad7e7a5,2
+np.float64,0x7fe60cd1cf6c19a3,0x408630d3d87a04b3,2
+np.float64,0x3ff89fa65c113f4c,0x3fefe3543773180c,2
+np.float64,0x3ffd253130ba4a62,0x3ff350b76ba692a0,2
+np.float64,0x7feaad7051f55ae0,0x40863259ff932d62,2
+np.float64,0x7fd9cc37cf33986f,0x40862c89c15f963b,2
+np.float64,0x3ff8c08de771811c,0x3ff00daa9c17acd7,2
+np.float64,0x7fea58b25d34b164,0x408632406d54cc6f,2
+np.float64,0x7fe5f161fd2be2c3,0x408630c9ddf272a5,2
+np.float64,0x3ff5840dbf8b081c,0x3fe9dc9117b4cbc7,2
+np.float64,0x3ff3fd762307faec,0x3fe6277cd530c640,2
+np.float64,0x3ff9095c98b212b9,0x3ff04abff170ac24,2
+np.float64,0x7feaac66017558cb,0x40863259afb4f8ce,2
+np.float64,0x7fd78f96bcaf1f2c,0x40862bd00175fdf9,2
+np.float64,0x3ffaca27e0959450,0x3ff1ab72b8f8633e,2
+np.float64,0x3ffb7f18cb96fe32,0x3ff22f81bcb8907b,2
+np.float64,0x3ffcce48d1199c92,0x3ff317276f62c0b2,2
+np.float64,0x3ffcb9a7f3797350,0x3ff30958e0d6a34d,2
+np.float64,0x7fda569ef6b4ad3d,0x40862cb43b33275a,2
+np.float64,0x7fde9f0893bd3e10,0x40862de8cc036283,2
+np.float64,0x3ff428be3928517c,0x3fe699bb5ab58904,2
+np.float64,0x7fa4d3344029a668,0x40861a3084989291,2
+np.float64,0x3ff03607bd006c0f,0x3fc4c4840cf35f48,2
+np.float64,0x3ff2b1335c056267,0x3fe25000846b75a2,2
+np.float64,0x7fe0cb8bd8e19717,0x40862ea65237d496,2
+np.float64,0x3fff4b1b7b9e9637,0x3ff4a83fb08e7b24,2
+np.float64,0x7fe7526140aea4c2,0x40863146ae86069c,2
+np.float64,0x7fbfcfb7c23f9f6f,0x4086231fc246ede5,2

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-arcsin.csv

@@ -0,0 +1,1429 @@
+dtype,input,output,ulperrortol
+np.float32,0xbe7d3a7c,0xbe7fe217,4
+np.float32,0x3dc102f0,0x3dc14c60,4
+np.float32,0xbe119c28,0xbe121aef,4
+np.float32,0xbe51cd68,0xbe534c75,4
+np.float32,0x3c04a300,0x3c04a35f,4
+np.float32,0xbf4f0b62,0xbf712a69,4
+np.float32,0x3ef61a5c,0x3f005cf6,4
+np.float32,0xbf13024c,0xbf1c97df,4
+np.float32,0x3e93b580,0x3e95d6b5,4
+np.float32,0x3e44e7b8,0x3e4623a5,4
+np.float32,0xbe35df20,0xbe36d773,4
+np.float32,0x3eecd2c0,0x3ef633cf,4
+np.float32,0x3f2772ba,0x3f36862a,4
+np.float32,0x3e211ea8,0x3e21cac5,4
+np.float32,0x3e3b3d90,0x3e3c4cc6,4
+np.float32,0x3f37c962,0x3f4d018c,4
+np.float32,0x3e92ad88,0x3e94c31a,4
+np.float32,0x3f356ffc,0x3f49a766,4
+np.float32,0x3f487ba2,0x3f665254,4
+np.float32,0x3f061c46,0x3f0d27ae,4
+np.float32,0xbee340a2,0xbeeb7722,4
+np.float32,0xbe85aede,0xbe874026,4
+np.float32,0x3f34cf9a,0x3f48c474,4
+np.float32,0x3e29a690,0x3e2a6fbd,4
+np.float32,0xbeb29428,0xbeb669d1,4
+np.float32,0xbe606d40,0xbe624370,4
+np.float32,0x3dae6860,0x3dae9e85,4
+np.float32,0xbf04872b,0xbf0b4d25,4
+np.float32,0x3f2080e2,0x3f2d7ab0,4
+np.float32,0xbec77dcc,0xbecceb27,4
+np.float32,0x3e0dda10,0x3e0e4f38,4
+np.float32,0xbefaf970,0xbf03262c,4
+np.float32,0x3f576a0c,0x3f7ffee6,4
+np.float32,0x3f222382,0x3f2f95d6,4
+np.float32,0x7fc00000,0x7fc00000,4
+np.float32,0x3e41c468,0x3e42f14e,4
+np.float32,0xbf2f64dd,0xbf4139a8,4
+np.float32,0xbf60ef90,0xbf895956,4
+np.float32,0xbf67c855,0xbf90eff0,4
+np.float32,0xbed35aee,0xbed9df00,4
+np.float32,0xbf2c7d92,0xbf3d448f,4
+np.float32,0x3f7b1604,0x3faff122,4
+np.float32,0xbf7c758b,0xbfb3bf87,4
+np.float32,0x3ecda1c8,0x3ed39acf,4
+np.float32,0x3f3af8ae,0x3f519fcb,4
+np.float32,0xbf16e6a3,0xbf2160fd,4
+np.float32,0x3f0c97d2,0x3f14d668,4
+np.float32,0x3f0a8060,0x3f1257b9,4
+np.float32,0x3f27905a,0x3f36ad57,4
+np.float32,0x3eeaeba4,0x3ef40efe,4
+np.float32,0x3e58dde0,0x3e5a8580,4
+np.float32,0xbf0cabe2,0xbf14ee6b,4
+np.float32,0xbe805ca8,0xbe81bf03,4
+np.float32,0x3f5462ba,0x3f7a7b85,4
+np.float32,0xbee235d0,0xbeea4d8b,4
+np.float32,0xbe880cb0,0xbe89b426,4
+np.float32,0x80000001,0x80000001,4
+np.float32,0x3f208c00,0x3f2d88f6,4
+np.float32,0xbf34f3d2,0xbf48f7a2,4
+np.float32,0x3f629428,0x3f8b1763,4
+np.float32,0xbf52a900,0xbf776b4a,4
+np.float32,0xbd17f8d0,0xbd1801be,4
+np.float32,0xbef7cada,0xbf0153d1,4
+np.float32,0x3f7d3b90,0x3fb63967,4
+np.float32,0xbd6a20b0,0xbd6a4160,4
+np.float32,0x3f740496,0x3fa1beb7,4
+np.float32,0x3ed8762c,0x3edf7dd9,4
+np.float32,0x3f53b066,0x3f793d42,4
+np.float32,0xbe9de718,0xbea084f9,4
+np.float32,0x3ea3ae90,0x3ea69b4b,4
+np.float32,0x3f1b8f00,0x3f273183,4
+np.float32,0x3f5cd6ac,0x3f852ead,4
+np.float32,0x3f29d510,0x3f39b169,4
+np.float32,0x3ee2a934,0x3eeace33,4
+np.float32,0x3eecac94,0x3ef608c2,4
+np.float32,0xbea915e2,0xbeac5203,4
+np.float32,0xbd316e90,0xbd317cc8,4
+np.float32,0xbf70b495,0xbf9c97b6,4
+np.float32,0xbe80d976,0xbe823ff3,4
+np.float32,0x3e9205f8,0x3e94143f,4
+np.float32,0x3f49247e,0x3f676296,4
+np.float32,0x3d9030c0,0x3d904f50,4
+np.float32,0x3e4df058,0x3e4f5a5c,4
+np.float32,0xbe1fd360,0xbe207b58,4
+np.float32,0xbf69dc7c,0xbf937006,4
+np.float32,0x3f36babe,0x3f4b7df3,4
+np.float32,0xbe8c9758,0xbe8e6bb7,4
+np.float32,0xbf4de72d,0xbf6f3c20,4
+np.float32,0xbecdad68,0xbed3a780,4
+np.float32,0xbf73e2cf,0xbfa18702,4
+np.float32,0xbece16a8,0xbed41a75,4
+np.float32,0x3f618a96,0x3f89fc6d,4
+np.float32,0xbf325853,0xbf454ea9,4
+np.float32,0x3f138568,0x3f1d3828,4
+np.float32,0xbf56a6e9,0xbf7e9748,4
+np.float32,0x3ef5d594,0x3f0035bf,4
+np.float32,0xbf408220,0xbf59dfaa,4
+np.float32,0xbed120e6,0xbed76dd5,4
+np.float32,0xbf6dbda5,0xbf986cee,4
+np.float32,0x3f744a38,0x3fa23282,4
+np.float32,0xbe4b56d8,0xbe4cb329,4
+np.float32,0x3f54c5f2,0x3f7b2d97,4
+np.float32,0xbd8b1c90,0xbd8b3801,4
+np.float32,0x3ee19a48,0x3ee9a03b,4
+np.float32,0x3f48460e,0x3f65fc3d,4
+np.float32,0x3eb541c0,0x3eb9461e,4
+np.float32,0xbea7d098,0xbeaaf98c,4
+np.float32,0xbda99e40,0xbda9d00c,4
+np.float32,0xbefb2ca6,0xbf03438d,4
+np.float32,0x3f4256be,0x3f5cab0b,4
+np.float32,0xbdbdb198,0xbdbdf74d,4
+np.float32,0xbf325b5f,0xbf4552e9,4
+np.float32,0xbf704d1a,0xbf9c00b4,4
+np.float32,0x3ebb1d04,0x3ebf8cf8,4
+np.float32,0xbed03566,0xbed66bf1,4
+np.float32,0x3e8fcee8,0x3e91c501,4
+np.float32,0xbf2e1eec,0xbf3f7b9d,4
+np.float32,0x3f33c4d2,0x3f474cac,4
+np.float32,0x3f598ef4,0x3f8201b4,4
+np.float32,0x3e09bb30,0x3e0a2660,4
+np.float32,0x3ed4e228,0x3edb8cdb,4
+np.float32,0x3eb7a190,0x3ebbd0a1,4
+np.float32,0xbd9ae630,0xbd9b0c18,4
+np.float32,0x3f43020e,0x3f5db2d7,4
+np.float32,0xbec06ac0,0xbec542d4,4
+np.float32,0x3f3dfde0,0x3f561674,4
+np.float32,0xbf64084a,0xbf8cabe6,4
+np.float32,0xbd6f95b0,0xbd6fb8b7,4
+np.float32,0x3f268640,0x3f354e2d,4
+np.float32,0xbe72b4bc,0xbe7509b2,4
+np.float32,0xbf3414fa,0xbf47bd5a,4
+np.float32,0xbf375218,0xbf4c566b,4
+np.float32,0x3f203c1a,0x3f2d2273,4
+np.float32,0xbd503530,0xbd504c2b,4
+np.float32,0xbc45e540,0xbc45e67b,4
+np.float32,0xbf175c4f,0xbf21f2c6,4
+np.float32,0x3f7432a6,0x3fa20b2b,4
+np.float32,0xbf43367f,0xbf5e03d8,4
+np.float32,0x3eb3997c,0x3eb780c4,4
+np.float32,0x3e5574c8,0x3e570878,4
+np.float32,0xbf04b57b,0xbf0b8349,4
+np.float32,0x3f6216d8,0x3f8a914b,4
+np.float32,0xbf57a237,0xbf80337d,4
+np.float32,0xbee1403a,0xbee93bee,4
+np.float32,0xbeaf9b9a,0xbeb33f3b,4
+np.float32,0xbf109374,0xbf19a223,4
+np.float32,0xbeae6824,0xbeb1f810,4
+np.float32,0xbcff9320,0xbcff9dbe,4
+np.float32,0x3ed205c0,0x3ed868a9,4
+np.float32,0x3d897c30,0x3d8996ad,4
+np.float32,0xbf2899d2,0xbf380d4c,4
+np.float32,0xbf54cb0b,0xbf7b36c2,4
+np.float32,0x3ea8e8ec,0x3eac2262,4
+np.float32,0x3ef5e1a0,0x3f003c9d,4
+np.float32,0xbf00c81e,0xbf06f1e2,4
+np.float32,0xbf346775,0xbf483181,4
+np.float32,0x3f7a4fe4,0x3fae077c,4
+np.float32,0x3f00776e,0x3f06948f,4
+np.float32,0xbe0a3078,0xbe0a9cbc,4
+np.float32,0xbeba0b06,0xbebe66be,4
+np.float32,0xbdff4e38,0xbdfff8b2,4
+np.float32,0xbe927f70,0xbe9492ff,4
+np.float32,0x3ebb07e0,0x3ebf7642,4
+np.float32,0x3ebcf8e0,0x3ec18c95,4
+np.float32,0x3f49bdfc,0x3f685b51,4
+np.float32,0x3cbc29c0,0x3cbc2dfd,4
+np.float32,0xbe9e951a,0xbea13bf1,4
+np.float32,0xbe8c237c,0xbe8df33d,4
+np.float32,0x3e17f198,0x3e1881c4,4
+np.float32,0xbd0b5220,0xbd0b5902,4
+np.float32,0xbf34c4a2,0xbf48b4f5,4
+np.float32,0xbedaa814,0xbee1ea94,4
+np.float32,0x3ebf5d6c,0x3ec42053,4
+np.float32,0x3cd04b40,0x3cd050ff,4
+np.float32,0xbec33fe0,0xbec85244,4
+np.float32,0xbf00b27a,0xbf06d8d8,4
+np.float32,0x3f15d7be,0x3f201243,4
+np.float32,0xbe3debd0,0xbe3f06f7,4
+np.float32,0xbea81704,0xbeab4418,4
+np.float32,0x1,0x1,4
+np.float32,0x3f49e6ba,0x3f689d8b,4
+np.float32,0x3f351030,0x3f491fc0,4
+np.float32,0x3e607de8,0x3e625482,4
+np.float32,0xbe8dbbe4,0xbe8f9c0e,4
+np.float32,0x3edbf350,0x3ee35924,4
+np.float32,0xbf0c84c4,0xbf14bf9c,4
+np.float32,0x3eb218b0,0x3eb5e61a,4
+np.float32,0x3e466dd0,0x3e47b138,4
+np.float32,0xbe8ece94,0xbe90ba01,4
+np.float32,0xbe82ec2a,0xbe84649a,4
+np.float32,0xbf7e1f10,0xbfb98b9e,4
+np.float32,0xbf2d00ea,0xbf3df688,4
+np.float32,0x3db7cdd0,0x3db80d36,4
+np.float32,0xbe388b98,0xbe398f25,4
+np.float32,0xbd86cb40,0xbd86e436,4
+np.float32,0x7f7fffff,0x7fc00000,4
+np.float32,0x3f472a60,0x3f6436c6,4
+np.float32,0xbf5b2c1d,0xbf838d87,4
+np.float32,0x3f0409ea,0x3f0abad8,4
+np.float32,0x3f47dd0e,0x3f6553f0,4
+np.float32,0x3e3eab00,0x3e3fc98a,4
+np.float32,0xbf7c2a7f,0xbfb2e19b,4
+np.float32,0xbeda0048,0xbee13112,4
+np.float32,0x3f46600a,0x3f62f5b2,4
+np.float32,0x3f45aef4,0x3f61de43,4
+np.float32,0x3dd40a50,0x3dd46bc4,4
+np.float32,0xbf6cdd0b,0xbf974191,4
+np.float32,0x3f78de4c,0x3faac725,4
+np.float32,0x3f3c39a4,0x3f53777f,4
+np.float32,0xbe2a30ec,0xbe2afc0b,4
+np.float32,0xbf3c0ef0,0xbf533887,4
+np.float32,0x3ecb6548,0x3ed12a53,4
+np.float32,0x3eb994e8,0x3ebde7fc,4
+np.float32,0x3d4c1ee0,0x3d4c3487,4
+np.float32,0xbf52cb6d,0xbf77a7eb,4
+np.float32,0x3eb905d4,0x3ebd4e80,4
+np.float32,0x3e712428,0x3e736d72,4
+np.float32,0xbf79ee6e,0xbfad22be,4
+np.float32,0x3de6f8b0,0x3de776c1,4
+np.float32,0x3e9b2898,0x3e9da325,4
+np.float32,0x3ea09b20,0x3ea35d20,4
+np.float32,0x3d0ea9a0,0x3d0eb103,4
+np.float32,0xbd911500,0xbd913423,4
+np.float32,0x3e004618,0x3e009c97,4
+np.float32,0x3f5e0e5a,0x3f86654c,4
+np.float32,0x3f2e6300,0x3f3fd88b,4
+np.float32,0x3e0cf5d0,0x3e0d68c3,4
+np.float32,0x3d6a16c0,0x3d6a376c,4
+np.float32,0x3f7174aa,0x3f9db53c,4
+np.float32,0xbe04bba0,0xbe051b81,4
+np.float32,0xbe6fdcb4,0xbe721c92,4
+np.float32,0x3f4379f0,0x3f5e6c31,4
+np.float32,0xbf680098,0xbf913257,4
+np.float32,0xbf3c31ca,0xbf536bea,4
+np.float32,0x3f59db58,0x3f824a4e,4
+np.float32,0xbf3ffc84,0xbf591554,4
+np.float32,0x3d1d5160,0x3d1d5b48,4
+np.float32,0x3f6c64ae,0x3f96a3da,4
+np.float32,0xbf1b49fd,0xbf26daaa,4
+np.float32,0x3ec80be0,0x3ecd8576,4
+np.float32,0x3f3becc0,0x3f530629,4
+np.float32,0xbea93890,0xbeac76c1,4
+np.float32,0x3f5b3acc,0x3f839bbd,4
+np.float32,0xbf5d6818,0xbf85bef9,4
+np.float32,0x3f794266,0x3fab9fa6,4
+np.float32,0xbee8eb7c,0xbef1cf3b,4
+np.float32,0xbf360a06,0xbf4a821e,4
+np.float32,0x3f441cf6,0x3f5f693d,4
+np.float32,0x3e60de40,0x3e62b742,4
+np.float32,0xbebb3d7e,0xbebfafdc,4
+np.float32,0x3e56a3a0,0x3e583e28,4
+np.float32,0x3f375bfe,0x3f4c6499,4
+np.float32,0xbf384d7d,0xbf4dbf9a,4
+np.float32,0x3efb03a4,0x3f032c06,4
+np.float32,0x3f1d5d10,0x3f29794d,4
+np.float32,0xbe25f7dc,0xbe26b41d,4
+np.float32,0x3f6d2f88,0x3f97aebb,4
+np.float32,0xbe9fa100,0xbea255cb,4
+np.float32,0xbf21dafa,0xbf2f382a,4
+np.float32,0x3d3870e0,0x3d3880d9,4
+np.float32,0x3eeaf00c,0x3ef413f4,4
+np.float32,0xbc884ea0,0xbc88503c,4
+np.float32,0xbf7dbdad,0xbfb80b6d,4
+np.float32,0xbf4eb713,0xbf709b46,4
+np.float32,0xbf1c0ad4,0xbf27cd92,4
+np.float32,0x3f323088,0x3f451737,4
+np.float32,0x3e405d88,0x3e4183e1,4
+np.float32,0x3d7ad580,0x3d7afdb4,4
+np.float32,0xbf207338,0xbf2d6927,4
+np.float32,0xbecf7948,0xbed59e1a,4
+np.float32,0x3f16ff94,0x3f217fde,4
+np.float32,0xbdf19588,0xbdf225dd,4
+np.float32,0xbf4d9654,0xbf6eb442,4
+np.float32,0xbf390b9b,0xbf4ed220,4
+np.float32,0xbe155a74,0xbe15e354,4
+np.float32,0x3f519e4c,0x3f759850,4
+np.float32,0xbee3f08c,0xbeec3b84,4
+np.float32,0xbf478be7,0xbf64d23b,4
+np.float32,0xbefdee50,0xbf04d92a,4
+np.float32,0x3e8def78,0x3e8fd1bc,4
+np.float32,0x3e3df2a8,0x3e3f0dee,4
+np.float32,0xbf413e22,0xbf5afd97,4
+np.float32,0xbf1b8bc4,0xbf272d71,4
+np.float32,0xbf31e5be,0xbf44af22,4
+np.float32,0x3de7e080,0x3de86010,4
+np.float32,0xbf5ddf7e,0xbf863645,4
+np.float32,0x3f3eba6a,0x3f57306e,4
+np.float32,0xff7fffff,0x7fc00000,4
+np.float32,0x3ec22d5c,0x3ec72973,4
+np.float32,0x80800000,0x80800000,4
+np.float32,0x3f032e0c,0x3f09ba82,4
+np.float32,0x3d74bd60,0x3d74e2b7,4
+np.float32,0xbea0d61e,0xbea39b42,4
+np.float32,0xbefdfa78,0xbf04e02a,4
+np.float32,0x3e5cb220,0x3e5e70ec,4
+np.float32,0xbe239e54,0xbe2452a4,4
+np.float32,0x3f452738,0x3f61090e,4
+np.float32,0x3e99a2e0,0x3e9c0a66,4
+np.float32,0x3e4394d8,0x3e44ca5f,4
+np.float32,0x3f4472e2,0x3f5fef14,4
+np.float32,0xbf46bc70,0xbf638814,4
+np.float32,0xbf0b910f,0xbf139c7a,4
+np.float32,0x3f36b4a6,0x3f4b753f,4
+np.float32,0x3e0bf478,0x3e0c64f6,4
+np.float32,0x3ce02480,0x3ce02ba9,4
+np.float32,0xbd904b10,0xbd9069b1,4
+np.float32,0xbf7f5d72,0xbfc00b70,4
+np.float32,0x3f62127e,0x3f8a8ca8,4
+np.float32,0xbf320253,0xbf44d6e4,4
+np.float32,0x3f2507be,0x3f335833,4
+np.float32,0x3f299284,0x3f395887,4
+np.float32,0xbd8211b0,0xbd82281d,4
+np.float32,0xbd3374c0,0xbd338376,4
+np.float32,0x3f36c56a,0x3f4b8d30,4
+np.float32,0xbf51f704,0xbf76331f,4
+np.float32,0xbe9871ca,0xbe9acab2,4
+np.float32,0xbe818d8c,0xbe82fa0f,4
+np.float32,0x3f08b958,0x3f103c18,4
+np.float32,0x3f22559a,0x3f2fd698,4
+np.float32,0xbf11f388,0xbf1b4db8,4
+np.float32,0x3ebe1990,0x3ec2c359,4
+np.float32,0xbe75ab38,0xbe7816b6,4
+np.float32,0x3e96102c,0x3e984c99,4
+np.float32,0xbe80d9d2,0xbe824052,4
+np.float32,0x3ef47588,0x3efeda7f,4
+np.float32,0xbe45e524,0xbe4725ea,4
+np.float32,0x3f7f9e7a,0x3fc213ff,4
+np.float32,0x3f1d3c36,0x3f294faa,4
+np.float32,0xbf3c58db,0xbf53a591,4
+np.float32,0x3f0d3d20,0x3f159c69,4
+np.float32,0x3f744be6,0x3fa23552,4
+np.float32,0x3f2e0cea,0x3f3f630e,4
+np.float32,0x3e193c10,0x3e19cff7,4
+np.float32,0xbf4150ac,0xbf5b19dd,4
+np.float32,0xbf145f72,0xbf1e4355,4
+np.float32,0xbb76cc00,0xbb76cc26,4
+np.float32,0x3f756780,0x3fa41b3e,4
+np.float32,0x3ea9b868,0x3eacfe3c,4
+np.float32,0x3d07c920,0x3d07cf7f,4
+np.float32,0xbf2263d4,0xbf2fe8ff,4
+np.float32,0x3e53b3f8,0x3e553daa,4
+np.float32,0xbf785be8,0xbfa9b5ba,4
+np.float32,0x3f324f7a,0x3f454254,4
+np.float32,0xbf2188f2,0xbf2ece5b,4
+np.float32,0xbe33781c,0xbe3466a2,4
+np.float32,0xbd3cf120,0xbd3d024c,4
+np.float32,0x3f06b18a,0x3f0dd70f,4
+np.float32,0x3f40d63e,0x3f5a5f6a,4
+np.float32,0x3f752340,0x3fa3a41e,4
+np.float32,0xbe1cf1c0,0xbe1d90bc,4
+np.float32,0xbf02d948,0xbf0957d7,4
+np.float32,0x3f73bed0,0x3fa14bf7,4
+np.float32,0x3d914920,0x3d916864,4
+np.float32,0x7fa00000,0x7fe00000,4
+np.float32,0xbe67a5d8,0xbe69aba7,4
+np.float32,0x3f689c4a,0x3f91eb9f,4
+np.float32,0xbf196e00,0xbf248601,4
+np.float32,0xbf50dacb,0xbf7444fe,4
+np.float32,0x3f628b86,0x3f8b0e1e,4
+np.float32,0x3f6ee2f2,0x3f99fe7f,4
+np.float32,0x3ee5df40,0x3eee6492,4
+np.float32,0x3f501746,0x3f72f41b,4
+np.float32,0xbf1f0f18,0xbf2ba164,4
+np.float32,0xbf1a8bfd,0xbf25ec01,4
+np.float32,0xbd4926f0,0xbd493ba9,4
+np.float32,0xbf4e364f,0xbf6fc17b,4
+np.float32,0x3e50c578,0x3e523ed4,4
+np.float32,0x3f65bf10,0x3f8e95ce,4
+np.float32,0xbe8d75a2,0xbe8f52f2,4
+np.float32,0xbf3f557e,0xbf581962,4
+np.float32,0xbeff2bfc,0xbf05903a,4
+np.float32,0x3f5e8bde,0x3f86e3d8,4
+np.float32,0xbf7a0012,0xbfad4b9b,4
+np.float32,0x3edefce0,0x3ee6b790,4
+np.float32,0xbf0003de,0xbf060f09,4
+np.float32,0x3efc4650,0x3f03e548,4
+np.float32,0x3f4582e4,0x3f6198f5,4
+np.float32,0x3f10086c,0x3f18f9d0,4
+np.float32,0x3f1cd304,0x3f28ca77,4
+np.float32,0x3f683366,0x3f916e8d,4
+np.float32,0xbed49392,0xbedb3675,4
+np.float32,0xbf6fe5f6,0xbf9b6c0e,4
+np.float32,0xbf59b416,0xbf8224f6,4
+np.float32,0x3d20c960,0x3d20d3f4,4
+np.float32,0x3f6b00d6,0x3f94dbe7,4
+np.float32,0x3f6c26ae,0x3f965352,4
+np.float32,0xbf370ea6,0xbf4bf5dd,4
+np.float32,0x3dfe7230,0x3dff1af1,4
+np.float32,0xbefc21a8,0xbf03d038,4
+np.float32,0x3f16a990,0x3f21156a,4
+np.float32,0xbef8ac0c,0xbf01d48f,4
+np.float32,0x3f170de8,0x3f21919d,4
+np.float32,0x3db9ef80,0x3dba3122,4
+np.float32,0x3d696400,0x3d698461,4
+np.float32,0x3f007aa2,0x3f069843,4
+np.float32,0x3f22827c,0x3f3010a9,4
+np.float32,0x3f3650dc,0x3f4ae6f1,4
+np.float32,0xbf1d8037,0xbf29a5e1,4
+np.float32,0xbf08fdc4,0xbf108d0e,4
+np.float32,0xbd8df350,0xbd8e1079,4
+np.float32,0xbf36bb32,0xbf4b7e98,4
+np.float32,0x3f2e3756,0x3f3f9ced,4
+np.float32,0x3d5a6f20,0x3d5a89aa,4
+np.float32,0x3f55d568,0x3f7d1889,4
+np.float32,0x3e1ed110,0x3e1f75d9,4
+np.float32,0x3e7386b8,0x3e75e1dc,4
+np.float32,0x3f48ea0e,0x3f670434,4
+np.float32,0x3e921fb0,0x3e942f14,4
+np.float32,0xbf0d4d0b,0xbf15af7f,4
+np.float32,0x3f179ed2,0x3f224549,4
+np.float32,0xbf3a328e,0xbf507e6d,4
+np.float32,0xbf74591a,0xbfa24b6e,4
+np.float32,0x3ec7d1c4,0x3ecd4657,4
+np.float32,0xbf6ecbed,0xbf99de85,4
+np.float32,0x3db0bd00,0x3db0f559,4
+np.float32,0x7f800000,0x7fc00000,4
+np.float32,0x3e0373b8,0x3e03d0d6,4
+np.float32,0xbf439784,0xbf5e9a04,4
+np.float32,0xbef97a9e,0xbf024ac6,4
+np.float32,0x3e4d71a8,0x3e4ed90a,4
+np.float32,0xbf14d868,0xbf1ed7e3,4
+np.float32,0xbf776870,0xbfa7ce37,4
+np.float32,0xbe32a500,0xbe339038,4
+np.float32,0xbf326d8a,0xbf456c3d,4
+np.float32,0xbe9b758c,0xbe9df3e7,4
+np.float32,0x3d9515a0,0x3d95376a,4
+np.float32,0x3e3f7320,0x3e40953e,4
+np.float32,0xbee57e7e,0xbeedf84f,4
+np.float32,0x3e821e94,0x3e838ffd,4
+np.float32,0x3f74beaa,0x3fa2f721,4
+np.float32,0xbe9b7672,0xbe9df4d9,4
+np.float32,0x3f4041fc,0x3f597e71,4
+np.float32,0xbe9ea7c4,0xbea14f92,4
+np.float32,0xbf800000,0xbfc90fdb,4
+np.float32,0x3e04fb90,0x3e055bfd,4
+np.float32,0xbf14d3d6,0xbf1ed245,4
+np.float32,0xbe84ebec,0xbe86763e,4
+np.float32,0x3f08e568,0x3f107039,4
+np.float32,0x3d8dc9e0,0x3d8de6ef,4
+np.float32,0x3ea4549c,0x3ea74a94,4
+np.float32,0xbebd2806,0xbec1bf51,4
+np.float32,0x3f311a26,0x3f439498,4
+np.float32,0xbf3d2222,0xbf54cf7e,4
+np.float32,0x3e00c500,0x3e011c81,4
+np.float32,0xbe35ed1c,0xbe36e5a9,4
+np.float32,0xbd4ec020,0xbd4ed6a0,4
+np.float32,0x3e1eb088,0x3e1f54eb,4
+np.float32,0x3cf94840,0x3cf9521a,4
+np.float32,0xbf010c5d,0xbf0740e0,4
+np.float32,0xbf3bd63b,0xbf52e502,4
+np.float32,0x3f233f30,0x3f310542,4
+np.float32,0x3ea24128,0x3ea519d7,4
+np.float32,0x3f478b38,0x3f64d124,4
+np.float32,0x3f1e0c6c,0x3f2a57ec,4
+np.float32,0xbf3ad294,0xbf51680a,4
+np.float32,0x3ede0554,0x3ee5a4b4,4
+np.float32,0x3e451a98,0x3e46577d,4
+np.float32,0x3f520164,0x3f764542,4
+np.float32,0x0,0x0,4
+np.float32,0xbd056cd0,0xbd0572db,4
+np.float32,0xbf58b018,0xbf812f5e,4
+np.float32,0x3e036eb0,0x3e03cbc3,4
+np.float32,0x3d1377a0,0x3d137fc9,4
+np.float32,0xbf692d3a,0xbf929a2c,4
+np.float32,0xbec60fb8,0xbecb5dea,4
+np.float32,0x3ed23340,0x3ed89a8e,4
+np.float32,0x3c87f040,0x3c87f1d9,4
+np.float32,0x3dac62f0,0x3dac9737,4
+np.float32,0xbed97c16,0xbee09f02,4
+np.float32,0xbf2d5f3c,0xbf3e769c,4
+np.float32,0xbc3b7c40,0xbc3b7d4c,4
+np.float32,0x3ed998ec,0x3ee0bedd,4
+np.float32,0x3dd86630,0x3dd8cdcb,4
+np.float32,0x3e8b4304,0x3e8d09ea,4
+np.float32,0x3f51e6b0,0x3f761697,4
+np.float32,0x3ec51f24,0x3eca5923,4
+np.float32,0xbf647430,0xbf8d2307,4
+np.float32,0x3f253d9c,0x3f339eb2,4
+np.float32,0x3dc969d0,0x3dc9bd4b,4
+np.float32,0xbc2f1300,0xbc2f13da,4
+np.float32,0xbf170007,0xbf21806d,4
+np.float32,0x3f757d10,0x3fa4412e,4
+np.float32,0xbe7864ac,0xbe7ae564,4
+np.float32,0x3f2ffe90,0x3f420cfb,4
+np.float32,0xbe576138,0xbe590012,4
+np.float32,0xbf517a21,0xbf755959,4
+np.float32,0xbf159cfe,0xbf1fc9d5,4
+np.float32,0xbf638b2a,0xbf8c22cf,4
+np.float32,0xff800000,0x7fc00000,4
+np.float32,0x3ed19ca0,0x3ed7f569,4
+np.float32,0x3f7c4460,0x3fb32d26,4
+np.float32,0x3ebfae6c,0x3ec477ab,4
+np.float32,0x3dd452d0,0x3dd4b4a8,4
+np.float32,0x3f471482,0x3f6413fb,4
+np.float32,0xbf49d704,0xbf6883fe,4
+np.float32,0xbd42c4e0,0xbd42d7af,4
+np.float32,0xbeb02994,0xbeb3d668,4
+np.float32,0x3f4d1fd8,0x3f6dedd2,4
+np.float32,0x3efb591c,0x3f035d11,4
+np.float32,0x80000000,0x80000000,4
+np.float32,0xbf50f782,0xbf7476ad,4
+np.float32,0x3d7232c0,0x3d7256f0,4
+np.float32,0x3f649460,0x3f8d46bb,4
+np.float32,0x3f5561bc,0x3f7c46a9,4
+np.float32,0x3e64f6a0,0x3e66ea5d,4
+np.float32,0x3e5b0470,0x3e5cb8f9,4
+np.float32,0xbe9b6b2c,0xbe9de904,4
+np.float32,0x3f6c33f4,0x3f966486,4
+np.float32,0x3f5cee54,0x3f854613,4
+np.float32,0x3ed3e044,0x3eda716e,4
+np.float32,0xbf3cac7f,0xbf542131,4
+np.float32,0x3c723500,0x3c723742,4
+np.float32,0x3de59900,0x3de614d3,4
+np.float32,0xbdf292f8,0xbdf32517,4
+np.float32,0x3f05c8b2,0x3f0cc59b,4
+np.float32,0xbf1ab182,0xbf261b14,4
+np.float32,0xbda396f0,0xbda3c39a,4
+np.float32,0xbf270ed0,0xbf360231,4
+np.float32,0x3f2063e6,0x3f2d557e,4
+np.float32,0x3c550280,0x3c550409,4
+np.float32,0xbe103b48,0xbe10b679,4
+np.float32,0xbebae390,0xbebf4f40,4
+np.float32,0x3f3bc868,0x3f52d0aa,4
+np.float32,0xbd62f880,0xbd631647,4
+np.float32,0xbe7a38f4,0xbe7cc833,4
+np.float32,0x3f09d796,0x3f118f39,4
+np.float32,0xbf5fa558,0xbf8802d0,4
+np.float32,0x3f111cc8,0x3f1a48b0,4
+np.float32,0x3e831958,0x3e849356,4
+np.float32,0xbf614dbd,0xbf89bc3b,4
+np.float32,0xbd521510,0xbd522cac,4
+np.float32,0x3f05af22,0x3f0ca7a0,4
+np.float32,0xbf1ac60e,0xbf2634df,4
+np.float32,0xbf6bd05e,0xbf95e3fe,4
+np.float32,0xbd1fa6e0,0xbd1fb13b,4
+np.float32,0xbeb82f7a,0xbebc68b1,4
+np.float32,0xbd92aaf8,0xbd92cb23,4
+np.float32,0xbe073a54,0xbe079fbf,4
+np.float32,0xbf198655,0xbf24a468,4
+np.float32,0x3f62f6d8,0x3f8b81ba,4
+np.float32,0x3eef4310,0x3ef8f4f9,4
+np.float32,0x3e8988e0,0x3e8b3eae,4
+np.float32,0xbf3ddba5,0xbf55e367,4
+np.float32,0x3dc6d2e0,0x3dc7232b,4
+np.float32,0xbf31040e,0xbf437601,4
+np.float32,0x3f1bb74a,0x3f276442,4
+np.float32,0xbf0075d2,0xbf0692b3,4
+np.float32,0xbf606ce0,0xbf88d0ff,4
+np.float32,0xbf083856,0xbf0fa39d,4
+np.float32,0xbdb25b20,0xbdb2950a,4
+np.float32,0xbeb86860,0xbebca5ae,4
+np.float32,0x3de83160,0x3de8b176,4
+np.float32,0xbf33a98f,0xbf472664,4
+np.float32,0x3e7795f8,0x3e7a1058,4
+np.float32,0x3e0ca6f8,0x3e0d192a,4
+np.float32,0xbf1aef60,0xbf2668c3,4
+np.float32,0xbda53b58,0xbda5695e,4
+np.float32,0xbf178096,0xbf221fc5,4
+np.float32,0xbf0a4159,0xbf120ccf,4
+np.float32,0x3f7bca36,0x3fb1d0df,4
+np.float32,0xbef94360,0xbf022b26,4
+np.float32,0xbef16f36,0xbefb6ad6,4
+np.float32,0x3f53a7e6,0x3f792e25,4
+np.float32,0xbf7c536f,0xbfb35993,4
+np.float32,0xbe84aaa0,0xbe8632a2,4
+np.float32,0x3ecb3998,0x3ed0fab9,4
+np.float32,0x3f539304,0x3f79090a,4
+np.float32,0xbf3c7816,0xbf53d3b3,4
+np.float32,0xbe7a387c,0xbe7cc7b7,4
+np.float32,0x3f7000e4,0x3f9b92b1,4
+np.float32,0x3e08fd70,0x3e0966e5,4
+np.float32,0x3db97ba0,0x3db9bcc8,4
+np.float32,0xbee99056,0xbef2886a,4
+np.float32,0xbf0668da,0xbf0d819e,4
+np.float32,0x3e58a408,0x3e5a4a51,4
+np.float32,0x3f3440b8,0x3f47faed,4
+np.float32,0xbf19a2ce,0xbf24c7ff,4
+np.float32,0xbe75e990,0xbe7856ee,4
+np.float32,0x3f3c865c,0x3f53e8cb,4
+np.float32,0x3e5e03d0,0x3e5fcac9,4
+np.float32,0x3edb8e34,0x3ee2e932,4
+np.float32,0xbf7e1f5f,0xbfb98ce4,4
+np.float32,0xbf7372ff,0xbfa0d0ae,4
+np.float32,0xbf3ee850,0xbf577548,4
+np.float32,0x3ef19658,0x3efb9737,4
+np.float32,0xbe8088de,0xbe81ecaf,4
+np.float32,0x800000,0x800000,4
+np.float32,0xbde39dd8,0xbde4167a,4
+np.float32,0xbf065d7a,0xbf0d7441,4
+np.float32,0xbde52c78,0xbde5a79b,4
+np.float32,0xbe3a28c0,0xbe3b333e,4
+np.float32,0x3f6e8b3c,0x3f998516,4
+np.float32,0x3f3485c2,0x3f485c39,4
+np.float32,0x3e6f2c68,0x3e71673e,4
+np.float32,0xbe4ec9cc,0xbe50385e,4
+np.float32,0xbf1c3bb0,0xbf280b39,4
+np.float32,0x3ec8ea18,0x3ece76f7,4
+np.float32,0x3e26b5f8,0x3e2774c9,4
+np.float32,0x3e1e4a38,0x3e1eed5c,4
+np.float32,0xbee7a106,0xbef05c6b,4
+np.float32,0xbf305928,0xbf4289d8,4
+np.float32,0x3f0c431c,0x3f147118,4
+np.float32,0xbe57ba6c,0xbe595b52,4
+np.float32,0x3eabc9cc,0x3eaf2fc7,4
+np.float32,0xbef1ed24,0xbefbf9ae,4
+np.float32,0xbf61b576,0xbf8a29cc,4
+np.float32,0x3e9c1ff4,0x3e9ea6cb,4
+np.float32,0x3f6c53b2,0x3f968dbe,4
+np.float32,0x3e2d1b80,0x3e2df156,4
+np.float32,0x3e9f2f70,0x3ea1de4a,4
+np.float32,0xbf5861ee,0xbf80e61a,4
+np.float32,0x3f429144,0x3f5d0505,4
+np.float32,0x3e235cc8,0x3e24103e,4
+np.float32,0xbf354879,0xbf496f6a,4
+np.float32,0xbf20a146,0xbf2da447,4
+np.float32,0x3e8d8968,0x3e8f6785,4
+np.float32,0x3f3fbc94,0x3f58b4c1,4
+np.float32,0x3f2c5f50,0x3f3d1b9f,4
+np.float32,0x3f7bf0f8,0x3fb23d23,4
+np.float32,0xbf218282,0xbf2ec60f,4
+np.float32,0x3f2545aa,0x3f33a93e,4
+np.float32,0xbf4b17be,0xbf6a9018,4
+np.float32,0xbb9df700,0xbb9df728,4
+np.float32,0x3f685d54,0x3f91a06c,4
+np.float32,0x3efdfe2c,0x3f04e24c,4
+np.float32,0x3ef1c5a0,0x3efbccd9,4
+np.float32,0xbf41d731,0xbf5be76e,4
+np.float32,0x3ebd1360,0x3ec1a919,4
+np.float32,0xbf706bd4,0xbf9c2d58,4
+np.float32,0x3ea525e4,0x3ea8279d,4
+np.float32,0xbe51f1b0,0xbe537186,4
+np.float32,0x3f5e8cf6,0x3f86e4f4,4
+np.float32,0xbdad2520,0xbdad5a19,4
+np.float32,0xbf5c5704,0xbf84b0e5,4
+np.float32,0x3f47b54e,0x3f65145e,4
+np.float32,0x3eb4fc78,0x3eb8fc0c,4
+np.float32,0x3dca1450,0x3dca68a1,4
+np.float32,0x3eb02a74,0x3eb3d757,4
+np.float32,0x3f74ae6a,0x3fa2db75,4
+np.float32,0x3f800000,0x3fc90fdb,4
+np.float32,0xbdb46a00,0xbdb4a5f2,4
+np.float32,0xbe9f2ba6,0xbea1da4e,4
+np.float32,0x3f0afa70,0x3f12e8f7,4
+np.float32,0xbf677b20,0xbf909547,4
+np.float32,0x3eff9188,0x3f05cacf,4
+np.float32,0x3f720562,0x3f9e911b,4
+np.float32,0xbf7180d8,0xbf9dc794,4
+np.float32,0xbee7d076,0xbef0919d,4
+np.float32,0x3f0432ce,0x3f0aea95,4
+np.float32,0x3f3bc4c8,0x3f52cb54,4
+np.float32,0xbea72f30,0xbeaa4ebe,4
+np.float32,0x3e90ed00,0x3e92ef33,4
+np.float32,0xbda63670,0xbda6654a,4
+np.float32,0xbf5a6f85,0xbf82d7e0,4
+np.float32,0x3e6e8808,0x3e70be34,4
+np.float32,0xbf4f3822,0xbf71768f,4
+np.float32,0x3e5c8a68,0x3e5e483f,4
+np.float32,0xbf0669d4,0xbf0d82c4,4
+np.float32,0xbf79f77c,0xbfad37b0,4
+np.float32,0x3f25c82c,0x3f345453,4
+np.float32,0x3f1b2948,0x3f26b188,4
+np.float32,0x3ef7e288,0x3f016159,4
+np.float32,0x3c274280,0x3c27433e,4
+np.float32,0xbf4c8fa0,0xbf6cfd5e,4
+np.float32,0x3ea4ccb4,0x3ea7c966,4
+np.float32,0xbf7b157e,0xbfafefca,4
+np.float32,0xbee4c2b0,0xbeed264d,4
+np.float32,0xbc1fd640,0xbc1fd6e6,4
+np.float32,0x3e892308,0x3e8ad4f6,4
+np.float32,0xbf3f69c7,0xbf5837ed,4
+np.float32,0x3ec879e8,0x3ecdfd05,4
+np.float32,0x3f07a8c6,0x3f0efa30,4
+np.float32,0x3f67b880,0x3f90dd4d,4
+np.float32,0x3e8a11c8,0x3e8bccd5,4
+np.float32,0x3f7df6fc,0x3fb8e935,4
+np.float32,0xbef3e498,0xbefe3599,4
+np.float32,0xbf18ad7d,0xbf2395d8,4
+np.float32,0x3f2bce74,0x3f3c57f5,4
+np.float32,0xbf38086e,0xbf4d5c2e,4
+np.float32,0x3f772d7a,0x3fa75c35,4
+np.float32,0xbf3b6e24,0xbf524c00,4
+np.float32,0xbdd39108,0xbdd3f1d4,4
+np.float32,0xbf691f6b,0xbf928974,4
+np.float32,0x3f146188,0x3f1e45e4,4
+np.float32,0xbf56045b,0xbf7d6e03,4
+np.float32,0xbf4b2ee4,0xbf6ab622,4
+np.float32,0xbf3fa3f6,0xbf588f9d,4
+np.float32,0x3f127bb0,0x3f1bf398,4
+np.float32,0x3ed858a0,0x3edf5d3e,4
+np.float32,0xbd6de3b0,0xbd6e05fa,4
+np.float32,0xbecc662c,0xbed24261,4
+np.float32,0xbd6791d0,0xbd67b170,4
+np.float32,0xbf146016,0xbf1e441e,4
+np.float32,0xbf61f04c,0xbf8a6841,4
+np.float32,0xbe7f16d0,0xbe80e6e7,4
+np.float32,0xbebf93e6,0xbec45b10,4
+np.float32,0xbe8a59fc,0xbe8c17d1,4
+np.float32,0xbebc7a0c,0xbec10426,4
+np.float32,0xbf2a682e,0xbf3a7649,4
+np.float32,0xbe18d0cc,0xbe19637b,4
+np.float32,0x3d7f5100,0x3d7f7b66,4
+np.float32,0xbf10f5fa,0xbf1a1998,4
+np.float32,0x3f25e956,0x3f347fdc,4
+np.float32,0x3e6e8658,0x3e70bc78,4
+np.float32,0x3f21a5de,0x3f2ef3a5,4
+np.float32,0xbf4e71d4,0xbf702607,4
+np.float32,0xbf49d6b6,0xbf688380,4
+np.float32,0xbdb729c0,0xbdb7687c,4
+np.float32,0xbf63e1f4,0xbf8c81c7,4
+np.float32,0x3dda6cb0,0x3ddad73e,4
+np.float32,0x3ee1bc40,0x3ee9c612,4
+np.float32,0x3ebdb5f8,0x3ec2581b,4
+np.float32,0x3f7d9576,0x3fb77646,4
+np.float32,0x3e087140,0x3e08d971,4
+np.float64,0xbfdba523cfb74a48,0xbfdc960ddd9c0506,3
+np.float64,0x3fb51773622a2ee0,0x3fb51d93f77089d5,3
+np.float64,0x3fc839f6d33073f0,0x3fc85f9a47dfe8e6,3
+np.float64,0xbfecba2d82f9745b,0xbff1d55416c6c993,3
+np.float64,0x3fd520fe47aa41fc,0x3fd58867f1179634,3
+np.float64,0x3fe1b369c56366d4,0x3fe2c1ac9dd2c45a,3
+np.float64,0xbfec25a7cd784b50,0xbff133417389b12d,3
+np.float64,0xbfd286342ea50c68,0xbfd2cb0bca22e66d,3
+np.float64,0x3fd5f6fe5eabedfc,0x3fd66bad16680d08,3
+np.float64,0xbfe863a87570c751,0xbfebbb9b637eb6dc,3
+np.float64,0x3fc97f5b4d32feb8,0x3fc9ab5066d8eaec,3
+np.float64,0xbfcb667af936ccf4,0xbfcb9d3017047a1d,3
+np.float64,0xbfd1b7b9afa36f74,0xbfd1f3c175706154,3
+np.float64,0x3fef97385b7f2e70,0x3ff6922a1a6c709f,3
+np.float64,0xbfd13e4205a27c84,0xbfd1757c993cdb74,3
+np.float64,0xbfd18d88aca31b12,0xbfd1c7dd75068f7d,3
+np.float64,0x3fe040ce0f60819c,0x3fe10c59d2a27089,3
+np.float64,0xbfddc7deddbb8fbe,0xbfdef9de5baecdda,3
+np.float64,0xbfcf6e96193edd2c,0xbfcfc1bb7396b9a3,3
+np.float64,0x3fd544f494aa89e8,0x3fd5ae850e2b37dd,3
+np.float64,0x3fe15b381fe2b670,0x3fe25841c7bfe2af,3
+np.float64,0xbfde793420bcf268,0xbfdfc2ddc7b4a341,3
+np.float64,0x3fd0d5db30a1abb8,0x3fd1092cef4aa4fb,3
+np.float64,0x3fe386a08c670d42,0x3fe50059bbf7f491,3
+np.float64,0xbfe0aae3a96155c8,0xbfe1880ef13e95ce,3
+np.float64,0xbfe80eeb03f01dd6,0xbfeb39e9f107e944,3
+np.float64,0xbfd531af3caa635e,0xbfd59a178f17552a,3
+np.float64,0x3fcced14ab39da28,0x3fcd2d9a806337ef,3
+np.float64,0xbfdb4c71bcb698e4,0xbfdc33d9d9daf708,3
+np.float64,0xbfde7375ecbce6ec,0xbfdfbc5611bc48ff,3
+np.float64,0x3fecc5707a798ae0,0x3ff1e2268d778017,3
+np.float64,0x3fe8f210a1f1e422,0x3fec9b3349a5baa2,3
+np.float64,0x3fe357f9b8e6aff4,0x3fe4c5a0b89a9228,3
+np.float64,0xbfe0f863b761f0c8,0xbfe1e3283494c3d4,3
+np.float64,0x3fd017c395a02f88,0x3fd044761f2f4a66,3
+np.float64,0x3febeb4746f7d68e,0x3ff0f6b955e7feb6,3
+np.float64,0xbfbdaaeeae3b55e0,0xbfbdbc0950109261,3
+np.float64,0xbfea013095f40261,0xbfee5b8fe8ad8593,3
+np.float64,0xbfe9f87b7973f0f7,0xbfee4ca3a8438d72,3
+np.float64,0x3fd37f77cfa6fef0,0x3fd3d018c825f057,3
+np.float64,0x3fb0799cee20f340,0x3fb07c879e7cb63f,3
+np.float64,0xbfdcfd581cb9fab0,0xbfde15e35314b52d,3
+np.float64,0xbfd49781b8a92f04,0xbfd4f6fa1516fefc,3
+np.float64,0x3fb3fcb6d627f970,0x3fb401ed44a713a8,3
+np.float64,0x3fd5737ef8aae6fc,0x3fd5dfe42d4416c7,3
+np.float64,0x7ff4000000000000,0x7ffc000000000000,3
+np.float64,0xbfe56ae780ead5cf,0xbfe776ea5721b900,3
+np.float64,0x3fd4567786a8acf0,0x3fd4b255421c161a,3
+np.float64,0x3fef6fb58cfedf6c,0x3ff62012dfcf0a33,3
+np.float64,0xbfd1dbcd3da3b79a,0xbfd2194fd628f74d,3
+np.float64,0x3fd9350016b26a00,0x3fd9e8b01eb023e9,3
+np.float64,0xbfe4fb3a69e9f675,0xbfe6e1d2c9eca56c,3
+np.float64,0x3fe9fe0f73f3fc1e,0x3fee5631cfd39772,3
+np.float64,0xbfd51c1bc6aa3838,0xbfd5833b3bd53543,3
+np.float64,0x3fc64158e12c82b0,0x3fc65e7352f237d7,3
+np.float64,0x3fd0d8ee1ba1b1dc,0x3fd10c5c99a16f0e,3
+np.float64,0x3fd5554e15aaaa9c,0x3fd5bfdb9ec9e873,3
+np.float64,0x3fe61ce209ec39c4,0x3fe869bc4c28437d,3
+np.float64,0xbfe4e42c8c69c859,0xbfe6c356dac7e2db,3
+np.float64,0xbfe157021062ae04,0xbfe2533ed39f4212,3
+np.float64,0x3fe844066cf0880c,0x3feb8aea0b7bd0a4,3
+np.float64,0x3fe55016586aa02c,0x3fe752e4b2a67b9f,3
+np.float64,0x3fdabce619b579cc,0x3fdb95809bc789d9,3
+np.float64,0x3fee03bae37c0776,0x3ff3778ba38ca882,3
+np.float64,0xbfeb2f5844f65eb0,0xbff03dd1b767d3c8,3
+np.float64,0x3fedcfdbaffb9fb8,0x3ff32e81d0639164,3
+np.float64,0x3fe06fc63ee0df8c,0x3fe142fc27f92eaf,3
+np.float64,0x3fe7ce90fd6f9d22,0x3fead8f832bbbf5d,3
+np.float64,0xbfbc0015ce380028,0xbfbc0e7470e06e86,3
+np.float64,0xbfe9b3de90f367bd,0xbfedd857931dfc6b,3
+np.float64,0xbfcb588f5936b120,0xbfcb8ef0124a4f21,3
+np.float64,0x3f8d376a503a6f00,0x3f8d37ab43e7988d,3
+np.float64,0xbfdb123a40b62474,0xbfdbf38b6cf5db92,3
+np.float64,0xbfee7da6be7cfb4e,0xbff433042cd9d5eb,3
+np.float64,0xbfc4c9e01b2993c0,0xbfc4e18dbafe37ef,3
+np.float64,0x3fedd42faffba860,0x3ff334790cd18a19,3
+np.float64,0x3fe9cdf772f39bee,0x3fee044f87b856ab,3
+np.float64,0x3fe0245881e048b2,0x3fe0eb5a1f739c8d,3
+np.float64,0xbfe4712bd9e8e258,0xbfe62cb3d82034aa,3
+np.float64,0x3fe9a16b46f342d6,0x3fedb972b2542551,3
+np.float64,0xbfe57ab4536af568,0xbfe78c34b03569c2,3
+np.float64,0x3fb6d6ceb22dada0,0x3fb6de976964d6dd,3
+np.float64,0x3fc3ac23a3275848,0x3fc3c02de53919b8,3
+np.float64,0xbfccb531e7396a64,0xbfccf43ec69f6281,3
+np.float64,0xbfd2f07fc8a5e100,0xbfd33a35a8c41b62,3
+np.float64,0xbfe3e5dd04e7cbba,0xbfe57940157c27ba,3
+np.float64,0x3feefe40757dfc80,0x3ff51bc72b846af6,3
+np.float64,0x8000000000000001,0x8000000000000001,3
+np.float64,0x3fecb7b766796f6e,0x3ff1d28972a0fc7e,3
+np.float64,0xbfea1bf1357437e2,0xbfee89a6532bfd71,3
+np.float64,0xbfca3983b7347308,0xbfca696463b791ef,3
+np.float64,0x10000000000000,0x10000000000000,3
+np.float64,0xbf886b45d030d680,0xbf886b6bbc04314b,3
+np.float64,0x3fd5224bb5aa4498,0x3fd589c92e82218f,3
+np.float64,0xbfec799874f8f331,0xbff18d5158b8e640,3
+np.float64,0xbf88124410302480,0xbf88126863350a16,3
+np.float64,0xbfe37feaaa66ffd6,0xbfe4f7e24382e79d,3
+np.float64,0x3fd777eca1aeefd8,0x3fd8076ead6d55dc,3
+np.float64,0x3fecaaeb3af955d6,0x3ff1c4159fa3e965,3
+np.float64,0xbfeb81e4e6f703ca,0xbff08d4e4c77fada,3
+np.float64,0xbfd7d0a0edafa142,0xbfd866e37010312e,3
+np.float64,0x3feda48c00fb4918,0x3ff2f3fd33c36307,3
+np.float64,0x3feb87ecc4770fda,0x3ff09336e490deda,3
+np.float64,0xbfefd78ad27faf16,0xbff78abbafb50ac1,3
+np.float64,0x3fe58e918c6b1d24,0x3fe7a70b38cbf016,3
+np.float64,0x3fda163b95b42c78,0x3fdade86b88ba4ee,3
+np.float64,0x3fe8fc1aaf71f836,0x3fecab3f93b59df5,3
+np.float64,0xbf8de56f903bcac0,0xbf8de5b527cec797,3
+np.float64,0xbfec112db2f8225b,0xbff11dd648de706f,3
+np.float64,0x3fc3214713264290,0x3fc333b1c862f7d0,3
+np.float64,0xbfeb5e5836f6bcb0,0xbff06ac364b49177,3
+np.float64,0x3fc23d9777247b30,0x3fc24d8ae3bcb615,3
+np.float64,0xbfdf0eed65be1dda,0xbfe036cea9b9dfb6,3
+np.float64,0xbfb2d5c85a25ab90,0xbfb2da24bb409ff3,3
+np.float64,0xbfecdda0c3f9bb42,0xbff1fdf94fc6e89e,3
+np.float64,0x3fdfe79154bfcf24,0x3fe0b338e0476a9d,3
+np.float64,0xbfd712ac6bae2558,0xbfd79abde21f287b,3
+np.float64,0x3fea3f148a747e2a,0x3feec6bed9d4fa04,3
+np.float64,0x3fd4879e4ca90f3c,0x3fd4e632fa4e2edd,3
+np.float64,0x3fe9137a9e7226f6,0x3fecd0c441088d6a,3
+np.float64,0xbfc75bf4ef2eb7e8,0xbfc77da8347d742d,3
+np.float64,0xbfd94090a0b28122,0xbfd9f5458816ed5a,3
+np.float64,0x3fde439cbcbc8738,0x3fdf85fbf496b61f,3
+np.float64,0xbfe18bacdce3175a,0xbfe29210e01237f7,3
+np.float64,0xbfd58ec413ab1d88,0xbfd5fcd838f0a934,3
+np.float64,0xbfeae5af2d75cb5e,0xbfeff1de1b4a06be,3
+np.float64,0x3fb64d1a162c9a30,0x3fb65458fb831354,3
+np.float64,0x3fc18b1e15231640,0x3fc1994c6ffd7a6a,3
+np.float64,0xbfd7b881bcaf7104,0xbfd84ce89a9ee8c7,3
+np.float64,0x3feb916a40f722d4,0x3ff09c8aa851d7c4,3
+np.float64,0x3fdab5fbb5b56bf8,0x3fdb8de43961bbde,3
+np.float64,0x3fe4f35402e9e6a8,0x3fe6d75dc5082894,3
+np.float64,0x3fe2fdb2e5e5fb66,0x3fe454e32a5d2182,3
+np.float64,0x3fe8607195f0c0e4,0x3febb6a4c3bf6a5c,3
+np.float64,0x3fd543ca9aaa8794,0x3fd5ad49203ae572,3
+np.float64,0x3fe8e05ca1f1c0ba,0x3fec7eff123dcc58,3
+np.float64,0x3fe298b6ca65316e,0x3fe3d81d2927c4dd,3
+np.float64,0x3fcfecea733fd9d8,0x3fd0220f1d0faf78,3
+np.float64,0xbfe2e739f065ce74,0xbfe439004e73772a,3
+np.float64,0xbfd1ae6b82a35cd8,0xbfd1ea129a5ee756,3
+np.float64,0xbfeb7edff576fdc0,0xbff08a5a638b8a8b,3
+np.float64,0x3fe5b645ff6b6c8c,0x3fe7dcee1faefe3f,3
+np.float64,0xbfd478427ba8f084,0xbfd4d5fc7c239e60,3
+np.float64,0xbfe39904e3e7320a,0xbfe517972b30b1e5,3
+np.float64,0xbfd3b75b6ba76eb6,0xbfd40acf20a6e074,3
+np.float64,0x3fd596267aab2c4c,0x3fd604b01faeaf75,3
+np.float64,0x3fe134463762688c,0x3fe229fc36784a72,3
+np.float64,0x3fd25dadf7a4bb5c,0x3fd2a0b9e04ea060,3
+np.float64,0xbfc05d3e0b20ba7c,0xbfc068bd2bb9966f,3
+np.float64,0x3f8cf517b039ea00,0x3f8cf556ed74b163,3
+np.float64,0x3fda87361cb50e6c,0x3fdb5a75af897e7f,3
+np.float64,0x3fe53e1926ea7c32,0x3fe73acf01b8ff31,3
+np.float64,0x3fe2e94857e5d290,0x3fe43b8cc820f9c7,3
+np.float64,0x3fd81fe6acb03fcc,0x3fd8bc623c0068cf,3
+np.float64,0xbfddf662c3bbecc6,0xbfdf2e76dc90786e,3
+np.float64,0x3fece174fbf9c2ea,0x3ff2026a1a889580,3
+np.float64,0xbfdc83c5b8b9078c,0xbfdd8dcf6ee3b7da,3
+np.float64,0x3feaf5448f75ea8a,0x3ff0075b108bcd0d,3
+np.float64,0xbfebf32f7ef7e65f,0xbff0fed42aaa826a,3
+np.float64,0x3fe389e5e8e713cc,0x3fe5047ade055ccb,3
+np.float64,0x3f635cdcc026ba00,0x3f635cddeea082ce,3
+np.float64,0x3fae580f543cb020,0x3fae5c9d5108a796,3
+np.float64,0x3fec9fafce793f60,0x3ff1b77bec654f00,3
+np.float64,0x3fb19d226e233a40,0x3fb1a0b32531f7ee,3
+np.float64,0xbfdf9a71e7bf34e4,0xbfe086cef88626c7,3
+np.float64,0x8010000000000000,0x8010000000000000,3
+np.float64,0xbfef170ba2fe2e17,0xbff54ed4675f5b8a,3
+np.float64,0xbfcc6e2f8f38dc60,0xbfccab65fc34d183,3
+np.float64,0x3fee756c4bfcead8,0x3ff4258782c137e6,3
+np.float64,0xbfd461c218a8c384,0xbfd4be3e391f0ff4,3
+np.float64,0xbfe3b64686e76c8d,0xbfe53caa16d6c90f,3
+np.float64,0xbfc1c65d8d238cbc,0xbfc1d51e58f82403,3
+np.float64,0x3fe6e06c63edc0d8,0x3fe97cb832eeb6a2,3
+np.float64,0xbfc9fc20b933f840,0xbfca2ab004312d85,3
+np.float64,0xbfe29aa6df65354e,0xbfe3da7ecf3ba466,3
+np.float64,0x3fea4df7d1749bf0,0x3feee0d448bd4746,3
+np.float64,0xbfedec6161fbd8c3,0xbff3563e1d943aa2,3
+np.float64,0x3fdb6f0437b6de08,0x3fdc5a1888b1213d,3
+np.float64,0xbfe270cbd3e4e198,0xbfe3a72ac27a0b0c,3
+np.float64,0xbfdfff8068bfff00,0xbfe0c1088e3b8983,3
+np.float64,0xbfd28edbe6a51db8,0xbfd2d416c8ed363e,3
+np.float64,0xbfb4e35f9229c6c0,0xbfb4e9531d2a737f,3
+np.float64,0xbfee6727e97cce50,0xbff40e7717576e46,3
+np.float64,0xbfddb5fbddbb6bf8,0xbfdee5aad78f5361,3
+np.float64,0xbfdf9d3e9dbf3a7e,0xbfe0886b191f2957,3
+np.float64,0x3fa57e77042afce0,0x3fa5801518ea9342,3
+np.float64,0x3f95c4e4882b89c0,0x3f95c55003c8e714,3
+np.float64,0x3fd9b10f61b36220,0x3fda6fe5d635a8aa,3
+np.float64,0xbfe2973411652e68,0xbfe3d641fe9885fd,3
+np.float64,0xbfee87bd5a7d0f7b,0xbff443bea81b3fff,3
+np.float64,0x3f9ea064c83d40c0,0x3f9ea19025085b2f,3
+np.float64,0xbfe4b823dfe97048,0xbfe689623d30dc75,3
+np.float64,0xbfa06a326c20d460,0xbfa06aeacbcd3eb8,3
+np.float64,0x3fe1e5c4c1e3cb8a,0x3fe2fe44b822f20e,3
+np.float64,0x3f99dafaa833b600,0x3f99dbaec10a1a0a,3
+np.float64,0xbfed7cb3877af967,0xbff2bfe9e556aaf9,3
+np.float64,0x3fd604f2e2ac09e4,0x3fd67a89408ce6ba,3
+np.float64,0x3fec57b60f78af6c,0x3ff16881f46d60f7,3
+np.float64,0xbfea2e3a17745c74,0xbfeea95c7190fd42,3
+np.float64,0xbfd60a7c37ac14f8,0xbfd6806ed642de35,3
+np.float64,0xbfe544b9726a8973,0xbfe743ac399d81d7,3
+np.float64,0xbfd13520faa26a42,0xbfd16c02034a8fe0,3
+np.float64,0xbfea9ea59ff53d4b,0xbfef70538ee12e00,3
+np.float64,0x3fd66633f8accc68,0x3fd6e23c13ab0e9e,3
+np.float64,0xbfe4071bd3e80e38,0xbfe5a3c9ba897d81,3
+np.float64,0xbfbe1659fa3c2cb0,0xbfbe2831d4fed196,3
+np.float64,0xbfd3312777a6624e,0xbfd37df09b9baeba,3
+np.float64,0x3fd13997caa27330,0x3fd170a4900c8907,3
+np.float64,0xbfe7cbc235ef9784,0xbfead4c4d6cbf129,3
+np.float64,0xbfe1456571628acb,0xbfe23e4ec768c8e2,3
+np.float64,0xbfedf1a044fbe340,0xbff35da96773e176,3
+np.float64,0x3fce38b1553c7160,0x3fce8270709774f9,3
+np.float64,0xbfecb01761f9602f,0xbff1c9e9d382f1f8,3
+np.float64,0xbfe0a03560e1406b,0xbfe17b8d5a1ca662,3
+np.float64,0x3fe50f37cbea1e70,0x3fe6fc55e1ae7da6,3
+np.float64,0xbfe12d64a0625aca,0xbfe221d3a7834e43,3
+np.float64,0xbf6fb288403f6500,0xbf6fb28d6f389db6,3
+np.float64,0x3fda831765b50630,0x3fdb55eecae58ca9,3
+np.float64,0x3fe1a0fe4c6341fc,0x3fe2ab9564304425,3
+np.float64,0xbfef2678a77e4cf1,0xbff56ff42b2797bb,3
+np.float64,0xbfab269c1c364d40,0xbfab29df1cd48779,3
+np.float64,0x3fe8ec82a271d906,0x3fec92567d7a6675,3
+np.float64,0xbfc235115f246a24,0xbfc244ee567682ea,3
+np.float64,0x3feef5bf8d7deb80,0x3ff50ad4875ee9bd,3
+np.float64,0x3fe768b5486ed16a,0x3fea421356160e65,3
+np.float64,0xbfd4255684a84aae,0xbfd47e8baf7ec7f6,3
+np.float64,0x3fc7f67f2b2fed00,0x3fc81ae83cf92dd5,3
+np.float64,0x3fe9b1b19a736364,0x3fedd4b0e24ee741,3
+np.float64,0x3fb27eb9e624fd70,0x3fb282dacd89ce28,3
+np.float64,0xbfd490b710a9216e,0xbfd4efcdeb213458,3
+np.float64,0xbfd1347b2ca268f6,0xbfd16b55dece2d38,3
+np.float64,0x3fc6a5668d2d4ad0,0x3fc6c41452c0c087,3
+np.float64,0xbfca7b209f34f640,0xbfcaac710486f6bd,3
+np.float64,0x3fc23a1a47247438,0x3fc24a047fd4c27a,3
+np.float64,0x3fdb1413a8b62828,0x3fdbf595e2d994bc,3
+np.float64,0xbfea69b396f4d367,0xbfef11bdd2b0709a,3
+np.float64,0x3fd14c9958a29934,0x3fd1846161b10422,3
+np.float64,0xbfe205f44be40be8,0xbfe325283aa3c6a8,3
+np.float64,0x3fecd03c9ef9a07a,0x3ff1ee85aaf52a01,3
+np.float64,0x3fe34281d7e68504,0x3fe4aab63e6de816,3
+np.float64,0xbfe120e2376241c4,0xbfe213023ab03939,3
+np.float64,0xbfe951edc4f2a3dc,0xbfed3615e38576f8,3
+np.float64,0x3fe5a2286f6b4450,0x3fe7c196e0ec10ed,3
+np.float64,0xbfed7a3e1f7af47c,0xbff2bcc0793555d2,3
+np.float64,0x3fe050274960a04e,0x3fe11e2e256ea5cc,3
+np.float64,0xbfcfa71f653f4e40,0xbfcffc11483d6a06,3
+np.float64,0x3f6ead2e403d5a00,0x3f6ead32f314c052,3
+np.float64,0x3fe3a2a026674540,0x3fe523bfe085f6ec,3
+np.float64,0xbfe294a62e65294c,0xbfe3d31ebd0b4ca2,3
+np.float64,0xbfb4894d06291298,0xbfb48ef4b8e256b8,3
+np.float64,0xbfc0c042c1218084,0xbfc0cc98ac2767c4,3
+np.float64,0xbfc6a32cb52d4658,0xbfc6c1d1597ed06b,3
+np.float64,0xbfd30f7777a61eee,0xbfd35aa39fee34eb,3
+np.float64,0x3fe7fc2c2eeff858,0x3feb1d8a558b5537,3
+np.float64,0x7fefffffffffffff,0x7ff8000000000000,3
+np.float64,0xbfdadf917bb5bf22,0xbfdbbbae9a9f67a0,3
+np.float64,0xbfcf0395e13e072c,0xbfcf5366015f7362,3
+np.float64,0xbfe8644c9170c899,0xbfebbc98e74a227d,3
+np.float64,0x3fc3b2d8e52765b0,0x3fc3c6f7d44cffaa,3
+np.float64,0x3fc57407b92ae810,0x3fc58e12ccdd47a1,3
+np.float64,0x3fd56a560daad4ac,0x3fd5d62b8dfcc058,3
+np.float64,0x3fd595deefab2bbc,0x3fd6046420b2f79b,3
+np.float64,0xbfd5360f50aa6c1e,0xbfd59ebaacd815b8,3
+np.float64,0x3fdfb6aababf6d54,0x3fe0970b8aac9f61,3
+np.float64,0x3ff0000000000000,0x3ff921fb54442d18,3
+np.float64,0xbfeb3a8958f67513,0xbff04872e8278c79,3
+np.float64,0x3f9e1ea6683c3d40,0x3f9e1fc326186705,3
+np.float64,0x3fe6b6d5986d6dac,0x3fe94175bd60b19d,3
+np.float64,0xbfee4d90b77c9b21,0xbff3e60e9134edc2,3
+np.float64,0x3fd806ce0cb00d9c,0x3fd8a14c4855a8f5,3
+np.float64,0x3fd54acc75aa9598,0x3fd5b4b72fcbb5df,3
+np.float64,0xbfe59761f16b2ec4,0xbfe7b2fa5d0244ac,3
+np.float64,0xbfcd4fa3513a9f48,0xbfcd92d0814a5383,3
+np.float64,0xbfdc827523b904ea,0xbfdd8c577b53053c,3
+np.float64,0xbfd4bb7f34a976fe,0xbfd51d00d9a99360,3
+np.float64,0xbfe818bc87f03179,0xbfeb48d1ea0199c5,3
+np.float64,0xbfa8a2e15c3145c0,0xbfa8a5510ba0e45c,3
+np.float64,0xbfb6d15f422da2c0,0xbfb6d922689da015,3
+np.float64,0x3fcd04eaab3a09d8,0x3fcd46131746ef08,3
+np.float64,0x3fcfb5cfbb3f6ba0,0x3fd0059d308237f3,3
+np.float64,0x3fe8dcf609f1b9ec,0x3fec7997973010b6,3
+np.float64,0xbfdf1834d7be306a,0xbfe03c1d4e2b48f0,3
+np.float64,0x3fee82ae50fd055c,0x3ff43b545066fe1a,3
+np.float64,0xbfde039c08bc0738,0xbfdf3d6ed4d2ee5c,3
+np.float64,0x3fec07389bf80e72,0x3ff1137ed0acd161,3
+np.float64,0xbfef44c010fe8980,0xbff5b488ad22a4c5,3
+np.float64,0x3f76e722e02dce00,0x3f76e72ab2759d88,3
+np.float64,0xbfcaa9e6053553cc,0xbfcadc41125fca93,3
+np.float64,0x3fed6088147ac110,0x3ff29c06c4ef35fc,3
+np.float64,0x3fd32bd836a657b0,0x3fd3785fdb75909f,3
+np.float64,0xbfeedbb1d97db764,0xbff4d87f6c82a93c,3
+np.float64,0xbfe40f31d5e81e64,0xbfe5ae292cf258a2,3
+np.float64,0x7ff8000000000000,0x7ff8000000000000,3
+np.float64,0xbfeb2b25bc76564c,0xbff039d81388550c,3
+np.float64,0x3fec5008fa78a012,0x3ff1604195801da3,3
+np.float64,0x3fce2d4f293c5aa0,0x3fce76b99c2db4da,3
+np.float64,0xbfdc435412b886a8,0xbfdd45e7b7813f1e,3
+np.float64,0x3fdf2c9d06be593c,0x3fe047cb03c141b6,3
+np.float64,0x3fddefc61ebbdf8c,0x3fdf26fb8fad9fae,3
+np.float64,0x3fab50218436a040,0x3fab537395eaf3bb,3
+np.float64,0xbfd5b95a8fab72b6,0xbfd62a191a59343a,3
+np.float64,0x3fdbf803b4b7f008,0x3fdcf211578e98c3,3
+np.float64,0xbfec8c255979184b,0xbff1a1bee108ed30,3
+np.float64,0x3fe33cdaffe679b6,0x3fe4a3a318cd994f,3
+np.float64,0x3fd8cf585cb19eb0,0x3fd97a408bf3c38c,3
+np.float64,0x3fe919dde07233bc,0x3fecdb0ea13a2455,3
+np.float64,0xbfd5ba35e4ab746c,0xbfd62b024805542d,3
+np.float64,0x3fd2f933e7a5f268,0x3fd343527565e97c,3
+np.float64,0xbfe5b9f8ddeb73f2,0xbfe7e1f772c3e438,3
+np.float64,0x3fe843cd92f0879c,0x3feb8a92d68eae3e,3
+np.float64,0xbfd096b234a12d64,0xbfd0c7beca2c6605,3
+np.float64,0xbfef3363da7e66c8,0xbff58c98dde6c27c,3
+np.float64,0x3fd51b01ddaa3604,0x3fd582109d89ead1,3
+np.float64,0x3fea0f10ff741e22,0x3fee736c2d2a2067,3
+np.float64,0x3fc276e7b724edd0,0x3fc28774520bc6d4,3
+np.float64,0xbfef9abc9f7f3579,0xbff69d49762b1889,3
+np.float64,0x3fe1539ec0e2a73e,0x3fe24f370b7687d0,3
+np.float64,0x3fad72350c3ae460,0x3fad765e7766682a,3
+np.float64,0x3fa289a47c251340,0x3fa28aae12f41646,3
+np.float64,0xbfe5c488e5eb8912,0xbfe7f05d7e7dcddb,3
+np.float64,0xbfc22ef1d7245de4,0xbfc23ebeb990a1b8,3
+np.float64,0x3fe59a0b80eb3418,0x3fe7b695fdcba1de,3
+np.float64,0xbfe9cad619f395ac,0xbfedff0514d91e2c,3
+np.float64,0x3fc8bc74eb3178e8,0x3fc8e48cb22da666,3
+np.float64,0xbfc5389a3f2a7134,0xbfc551cd6febc544,3
+np.float64,0x3fce82feb33d0600,0x3fceceecce2467ef,3
+np.float64,0x3fda346791b468d0,0x3fdaff95154a4ca6,3
+np.float64,0x3fd04501fea08a04,0x3fd073397b32607e,3
+np.float64,0xbfb6be498a2d7c90,0xbfb6c5f93aeb0e57,3
+np.float64,0x3fe1f030dd63e062,0x3fe30ad8fb97cce0,3
+np.float64,0xbfee3fb36dfc7f67,0xbff3d0a5e380b86f,3
+np.float64,0xbfa876773c30ecf0,0xbfa878d9d3df6a3f,3
+np.float64,0x3fdb58296eb6b054,0x3fdc40ceffb17f82,3
+np.float64,0xbfea16b5d8742d6c,0xbfee809b99fd6adc,3
+np.float64,0xbfdc5062b6b8a0c6,0xbfdd547623275fdb,3
+np.float64,0x3fef6db242fedb64,0x3ff61ab4cdaef467,3
+np.float64,0xbfc9f778f933eef0,0xbfca25eef1088167,3
+np.float64,0xbfd22063eba440c8,0xbfd260c8766c69cf,3
+np.float64,0x3fdd2379f2ba46f4,0x3fde40b025cb1ffa,3
+np.float64,0xbfea967af2f52cf6,0xbfef61a178774636,3
+np.float64,0x3fe4f5b49fe9eb6a,0x3fe6da8311a5520e,3
+np.float64,0x3feccde17b799bc2,0x3ff1ebd0ea228b71,3
+np.float64,0x3fe1bb76506376ec,0x3fe2cb56fca01840,3
+np.float64,0xbfef94e583ff29cb,0xbff68aeab8ba75a2,3
+np.float64,0x3fed024a55fa0494,0x3ff228ea5d456e9d,3
+np.float64,0xbfe877b2a8f0ef65,0xbfebdaa1a4712459,3
+np.float64,0x3fef687a8d7ed0f6,0x3ff60cf5fef8d448,3
+np.float64,0xbfeeb2dc8afd65b9,0xbff48dda6a906cd6,3
+np.float64,0x3fdb2e28aeb65c50,0x3fdc12620655eb7a,3
+np.float64,0x3fedc1863afb830c,0x3ff31ae823315e83,3
+np.float64,0xbfe6b1bb546d6376,0xbfe93a38163e3a59,3
+np.float64,0x3fe479c78468f390,0x3fe637e5c0fc5730,3
+np.float64,0x3fbad1fade35a3f0,0x3fbade9a43ca05cf,3
+np.float64,0xbfe2d1c563e5a38b,0xbfe41e712785900c,3
+np.float64,0xbfc08c33ed211868,0xbfc09817a752d500,3
+np.float64,0xbfecce0935f99c12,0xbff1ebfe84524037,3
+np.float64,0x3fce4ef0e73c9de0,0x3fce995638a3dc48,3
+np.float64,0xbfd2fb2343a5f646,0xbfd345592517ca18,3
+np.float64,0x3fd848f7cdb091f0,0x3fd8e8bee5f7b49a,3
+np.float64,0x3fe532b7d2ea6570,0x3fe72b9ac747926a,3
+np.float64,0x3fd616aadcac2d54,0x3fd68d692c5cad42,3
+np.float64,0x3fd7720eb3aee41c,0x3fd801206a0e1e43,3
+np.float64,0x3fee835a35fd06b4,0x3ff43c7175eb7a54,3
+np.float64,0xbfe2e8f70b65d1ee,0xbfe43b2800a947a7,3
+np.float64,0xbfed38f45d7a71e9,0xbff26acd6bde7174,3
+np.float64,0xbfc0c62661218c4c,0xbfc0d28964d66120,3
+np.float64,0x3fe97940bef2f282,0x3fed76b986a74ee3,3
+np.float64,0x3fc96f7dc532def8,0x3fc99b20044c8fcf,3
+np.float64,0xbfd60201eeac0404,0xbfd677675efaaedc,3
+np.float64,0x3fe63c0867ec7810,0x3fe894f060200140,3
+np.float64,0xbfef6144b37ec289,0xbff5fa589a515ba8,3
+np.float64,0xbfde2da0c8bc5b42,0xbfdf6d0b59e3232a,3
+np.float64,0xbfd7401612ae802c,0xbfd7cb74ddd413b9,3
+np.float64,0x3fe41c012de83802,0x3fe5be9d87da3f82,3
+np.float64,0x3fdf501609bea02c,0x3fe05c1d96a2270b,3
+np.float64,0x3fcf9fa1233f3f40,0x3fcff45598e72f07,3
+np.float64,0x3fd4e3895ea9c714,0x3fd547580d8392a2,3
+np.float64,0x3fe1e8ff5fe3d1fe,0x3fe3022a0b86a2ab,3
+np.float64,0xbfe0aa55956154ab,0xbfe18768823da589,3
+np.float64,0x3fb2a0aa26254150,0x3fb2a4e1faff1c93,3
+np.float64,0x3fd3823417a70468,0x3fd3d2f808dbb167,3
+np.float64,0xbfaed323643da640,0xbfaed7e9bef69811,3
+np.float64,0x3fe661e8c4ecc3d2,0x3fe8c9c535f43c16,3
+np.float64,0xbfa429777c2852f0,0xbfa42acd38ba02a6,3
+np.float64,0x3fb5993ea22b3280,0x3fb59fd353e47397,3
+np.float64,0x3fee62d21efcc5a4,0x3ff40788f9278ade,3
+np.float64,0xbf813fb810227f80,0xbf813fc56d8f3c53,3
+np.float64,0x3fd56205deaac40c,0x3fd5cd59671ef193,3
+np.float64,0x3fd31a4de5a6349c,0x3fd365fe401b66e8,3
+np.float64,0xbfec7cc7a478f98f,0xbff190cf69703ca4,3
+np.float64,0xbf755881a02ab100,0xbf755887f52e7794,3
+np.float64,0x3fdd1c92e6ba3924,0x3fde38efb4e8605c,3
+np.float64,0x3fdf49da80be93b4,0x3fe0588af8dd4a34,3
+np.float64,0x3fe1fcdbf2e3f9b8,0x3fe31a27b9d273f2,3
+np.float64,0x3fe2a0f18be541e4,0x3fe3e23b159ce20f,3
+np.float64,0xbfed0f1561fa1e2b,0xbff23820fc0a54ca,3
+np.float64,0x3fe34a006c669400,0x3fe4b419b9ed2b83,3
+np.float64,0xbfd51be430aa37c8,0xbfd583005a4d62e7,3
+np.float64,0x3fe5ec4e336bd89c,0x3fe826caad6b0f65,3
+np.float64,0xbfdad71b1fb5ae36,0xbfdbb25bef8b53d8,3
+np.float64,0xbfe8eac2d871d586,0xbfec8f8cac7952f9,3
+np.float64,0xbfe1d5aef663ab5e,0xbfe2eae14b7ccdfd,3
+np.float64,0x3fec11d3157823a6,0x3ff11e8279506753,3
+np.float64,0xbfe67ff1166cffe2,0xbfe8f3e61c1dfd32,3
+np.float64,0xbfd101eecda203de,0xbfd136e0e9557022,3
+np.float64,0x3fde6c9e5cbcd93c,0x3fdfb48ee7efe134,3
+np.float64,0x3fec3ede9c787dbe,0x3ff14dead1e5cc1c,3
+np.float64,0x3fe7a022086f4044,0x3fea93ce2980b161,3
+np.float64,0xbfc3b2b1b7276564,0xbfc3c6d02d60bb21,3
+np.float64,0x7ff0000000000000,0x7ff8000000000000,3
+np.float64,0x3fe60b5647ec16ac,0x3fe8517ef0544b40,3
+np.float64,0xbfd20ab654a4156c,0xbfd24a2f1b8e4932,3
+np.float64,0xbfe4aa1e2f69543c,0xbfe677005cbd2646,3
+np.float64,0xbfc831cc0b306398,0xbfc8574910d0b86d,3
+np.float64,0xbfc3143495262868,0xbfc3267961b79198,3
+np.float64,0x3fc14d64c1229ac8,0x3fc15afea90a319d,3
+np.float64,0x3fc0a5a207214b48,0x3fc0b1bd2f15c1b0,3
+np.float64,0xbfc0b8351521706c,0xbfc0c4792672d6db,3
+np.float64,0xbfdc383600b8706c,0xbfdd398429e163bd,3
+np.float64,0x3fd9e17321b3c2e8,0x3fdaa4c4d140a622,3
+np.float64,0xbfd44f079ea89e10,0xbfd4aa7d6deff4ab,3
+np.float64,0xbfc3de52a927bca4,0xbfc3f2f8f65f4c3f,3
+np.float64,0x3fe7779d566eef3a,0x3fea57f8592dbaad,3
+np.float64,0xbfe309039e661207,0xbfe462f47f9a64e5,3
+np.float64,0x3fd8e06d08b1c0dc,0x3fd98cc946e440a6,3
+np.float64,0x3fdde66c9ebbccd8,0x3fdf1c68009a8dc1,3
+np.float64,0x3fd4369c6ba86d38,0x3fd490bf460a69e4,3
+np.float64,0xbfe132252fe2644a,0xbfe22775e109cc2e,3
+np.float64,0x3fee15483c7c2a90,0x3ff39111de89036f,3
+np.float64,0xbfc1d5ee8123abdc,0xbfc1e4d66c6871a5,3
+np.float64,0x3fc851c52b30a388,0x3fc877d93fb4ae1a,3
+np.float64,0x3fdaade707b55bd0,0x3fdb85001661fffe,3
+np.float64,0xbfe79fb7f96f3f70,0xbfea9330ec27ac10,3
+np.float64,0xbfe8b0f725f161ee,0xbfec3411c0e4517a,3
+np.float64,0xbfea79f5f374f3ec,0xbfef2e9dd9270488,3
+np.float64,0x3fe0b5fe5b616bfc,0x3fe19512a36a4534,3
+np.float64,0xbfad7c622c3af8c0,0xbfad808fea96a804,3
+np.float64,0xbfe3e24dbce7c49c,0xbfe574b4c1ea9818,3
+np.float64,0xbfe80b038af01607,0xbfeb33fec279576a,3
+np.float64,0xbfef69e2ea7ed3c6,0xbff610a5593a18bc,3
+np.float64,0x3fdcc0bb39b98178,0x3fddd1f8c9a46430,3
+np.float64,0xbfba39976a347330,0xbfba4563bb5369a4,3
+np.float64,0xbfebf9768ef7f2ed,0xbff10548ab725f74,3
+np.float64,0xbfec21c066f84381,0xbff12f2803ba052f,3
+np.float64,0xbfca216a6b3442d4,0xbfca50c5e1e5748e,3
+np.float64,0x3fd5e40da4abc81c,0x3fd65783f9a22946,3
+np.float64,0x3fc235ca17246b98,0x3fc245a8f453173f,3
+np.float64,0x3fecb5b867796b70,0x3ff1d046a0bfda69,3
+np.float64,0x3fcb457fef368b00,0x3fcb7b6daa8165a7,3
+np.float64,0xbfa5ed6f7c2bdae0,0xbfa5ef27244e2e42,3
+np.float64,0x3fecf618a1f9ec32,0x3ff21a86cc104542,3
+np.float64,0x3fe9d95413f3b2a8,0x3fee178dcafa11fc,3
+np.float64,0xbfe93a5357f274a7,0xbfed0f9a565da84a,3
+np.float64,0xbfeb9e45ff773c8c,0xbff0a93cab8e258d,3
+np.float64,0x3fcbd9d0bd37b3a0,0x3fcc134e87cae241,3
+np.float64,0x3fe55d4db76aba9c,0x3fe764a0e028475a,3
+np.float64,0xbfc8a6fc71314df8,0xbfc8ceaafbfc59a7,3
+np.float64,0x3fe0615fa660c2c0,0x3fe1323611c4cbc2,3
+np.float64,0x3fb965558632cab0,0x3fb9700b84de20ab,3
+np.float64,0x8000000000000000,0x8000000000000000,3
+np.float64,0x3fe76776c6eeceee,0x3fea40403e24a9f1,3
+np.float64,0x3fe3b7f672676fec,0x3fe53ece71a1a1b1,3
+np.float64,0xbfa9b82ba4337050,0xbfa9baf15394ca64,3
+np.float64,0xbfe31faf49663f5e,0xbfe47f31b1ca73dc,3
+np.float64,0xbfcc4c6beb3898d8,0xbfcc88c5f814b2c1,3
+np.float64,0x3fd481530aa902a8,0x3fd4df8df03bc155,3
+np.float64,0x3fd47593b8a8eb28,0x3fd4d327ab78a1a8,3
+np.float64,0x3fd70e6ccbae1cd8,0x3fd7962fe8b63d46,3
+np.float64,0x3fd25191f7a4a324,0x3fd2941623c88e02,3
+np.float64,0x3fd0603ef0a0c07c,0x3fd08f64e97588dc,3
+np.float64,0xbfc653bae52ca774,0xbfc6711e5e0d8ea9,3
+np.float64,0xbfd11db8fea23b72,0xbfd153b63c6e8812,3
+np.float64,0xbfea9bde25f537bc,0xbfef6b52268e139a,3
+np.float64,0x1,0x1,3
+np.float64,0xbfefd3806d7fa701,0xbff776dcef9583ca,3
+np.float64,0xbfe0fb8cfde1f71a,0xbfe1e6e2e774a8f8,3
+np.float64,0x3fea384534f4708a,0x3feebadaa389be0d,3
+np.float64,0x3feff761c97feec4,0x3ff866157b9d072d,3
+np.float64,0x3fe7131ccb6e263a,0x3fe9c58b4389f505,3
+np.float64,0x3fe9084f7872109e,0x3fecbed0355dbc8f,3
+np.float64,0x3f708e89e0211d00,0x3f708e8cd4946b9e,3
+np.float64,0xbfe39185f067230c,0xbfe50e1cd178244d,3
+np.float64,0x3fd67cc1a9acf984,0x3fd6fa514784b48c,3
+np.float64,0xbfecaef005f95de0,0xbff1c89c9c3ef94a,3
+np.float64,0xbfe12eec81e25dd9,0xbfe223a4285bba9a,3
+np.float64,0x3fbe7f9faa3cff40,0x3fbe92363525068d,3
+np.float64,0xbfe1950b2b632a16,0xbfe29d45fc1e4ce9,3
+np.float64,0x3fe45049e6e8a094,0x3fe6020de759e383,3
+np.float64,0x3fe4d10c8969a21a,0x3fe6aa1fe42cbeb9,3
+np.float64,0xbfe9d04658f3a08d,0xbfee08370a0dbf0c,3
+np.float64,0x3fe14fb314e29f66,0x3fe24a8d73663521,3
+np.float64,0xbfef4abfe4fe9580,0xbff5c2c1ff1250ca,3
+np.float64,0xbfe6162b366c2c56,0xbfe86073ac3c6243,3
+np.float64,0x3feffe781e7ffcf0,0x3ff8d2cbedd6a1b5,3
+np.float64,0xbff0000000000000,0xbff921fb54442d18,3
+np.float64,0x3fc1dc45ad23b888,0x3fc1eb3d9bddda58,3
+np.float64,0xbfe793f6fcef27ee,0xbfea81c93d65aa64,3
+np.float64,0x3fdef6d2bbbdeda4,0x3fe029079d42efb5,3
+np.float64,0xbfdf0ac479be1588,0xbfe0346dbc95963f,3
+np.float64,0xbfd33927d7a67250,0xbfd38653f90a5b73,3
+np.float64,0xbfe248b072e49161,0xbfe37631ef6572e1,3
+np.float64,0xbfc8ceb6af319d6c,0xbfc8f7288657f471,3
+np.float64,0x3fdd7277fcbae4f0,0x3fde99886e6766ef,3
+np.float64,0xbfe0d30c6561a619,0xbfe1b72f90bf53d6,3
+np.float64,0xbfcb0fe07d361fc0,0xbfcb448e2eae9542,3
+np.float64,0xbfe351f57fe6a3eb,0xbfe4be13eef250f2,3
+np.float64,0x3fe85ec02cf0bd80,0x3febb407e2e52e4c,3
+np.float64,0x3fc8bc59b53178b0,0x3fc8e470f65800ec,3
+np.float64,0xbfd278d447a4f1a8,0xbfd2bd133c9c0620,3
+np.float64,0x3feda5cfd87b4ba0,0x3ff2f5ab4324f43f,3
+np.float64,0xbfd2b32a36a56654,0xbfd2fa09c36afd34,3
+np.float64,0xbfed4a81cb7a9504,0xbff28077a4f4fff4,3
+np.float64,0x3fdf079bf9be0f38,0x3fe0329f7fb13f54,3
+np.float64,0x3fd14097f6a28130,0x3fd177e9834ec23f,3
+np.float64,0xbfaeab11843d5620,0xbfaeafc5531eb6b5,3
+np.float64,0xbfac3f8c14387f20,0xbfac433893d53360,3
+np.float64,0xbfc139d7ed2273b0,0xbfc14743adbbe660,3
+np.float64,0x3fe78cb02cef1960,0x3fea7707f76edba9,3
+np.float64,0x3fefe16b41ffc2d6,0x3ff7bff36a7aa7b8,3
+np.float64,0x3fec5260d378a4c2,0x3ff162c588b0da38,3
+np.float64,0x3fedb146f17b628e,0x3ff304f90d3a15d1,3
+np.float64,0x3fd1fd45f7a3fa8c,0x3fd23c2dc3929e20,3
+np.float64,0x3fe0898a5ee11314,0x3fe1610c63e726eb,3
+np.float64,0x3fe7719946eee332,0x3fea4f205eecb59f,3
+np.float64,0x3fe955218972aa44,0x3fed3b530c1f7651,3
+np.float64,0x3fe0ccbf4461997e,0x3fe1afc7b4587836,3
+np.float64,0xbfe9204314f24086,0xbfece5605780e346,3
+np.float64,0xbfe552017feaa403,0xbfe755773cbd74d5,3
+np.float64,0x3fd8ce4b32b19c98,0x3fd9791c8dd44eae,3
+np.float64,0x3fef89acd9ff135a,0x3ff668f78adf7ced,3
+np.float64,0x3fc9d713ad33ae28,0x3fca04da6c293bbd,3
+np.float64,0xbfe22d9c4de45b38,0xbfe3553effadcf92,3
+np.float64,0x3fa5cda38c2b9b40,0x3fa5cf53c5787482,3
+np.float64,0x3fa878ebdc30f1e0,0x3fa87b4f2bf1d4c3,3
+np.float64,0x3fe8030353700606,0x3feb27e196928789,3
+np.float64,0x3fb50607222a0c10,0x3fb50c188ce391e6,3
+np.float64,0x3fd9ba4ab4b37494,0x3fda79fa8bd40f45,3
+np.float64,0x3fb564598e2ac8b0,0x3fb56abe42d1ba13,3
+np.float64,0xbfd1177c83a22efa,0xbfd14d3d7ef30cc4,3
+np.float64,0xbfd952cec7b2a59e,0xbfda09215d17c0ac,3
+np.float64,0x3fe1d8066663b00c,0x3fe2edb35770b8dd,3
+np.float64,0xbfc89427a3312850,0xbfc8bb7a7c389497,3
+np.float64,0xbfe86ebfd3f0dd80,0xbfebccc2ba0f506c,3
+np.float64,0x3fc390578b2720b0,0x3fc3a40cb7f5f728,3
+np.float64,0xbfd122f9b8a245f4,0xbfd15929dc57a897,3
+np.float64,0x3f8d0636d03a0c80,0x3f8d06767de576df,3
+np.float64,0xbfe4b55d8b696abb,0xbfe685be537a9637,3
+np.float64,0xbfdfd51cf9bfaa3a,0xbfe0a894fcff0c76,3
+np.float64,0xbfd37c1f52a6f83e,0xbfd3cc9593c37aad,3
+np.float64,0x3fd0e8283ea1d050,0x3fd11c25c800785a,3
+np.float64,0x3fd3160784a62c10,0x3fd36183a6c2880c,3
+np.float64,0x3fd4c66e57a98cdc,0x3fd5288fe3394eff,3
+np.float64,0x3fee2f7e3afc5efc,0x3ff3b8063eb30cdc,3
+np.float64,0xbfe526773a6a4cee,0xbfe71b4364215b18,3
+np.float64,0x3fea01181e740230,0x3fee5b65eccfd130,3
+np.float64,0xbfe51c03f76a3808,0xbfe70d5919d37587,3
+np.float64,0x3fd97e1375b2fc28,0x3fda3845da40b22b,3
+np.float64,0x3fd5c14a14ab8294,0x3fd632890d07ed03,3
+np.float64,0xbfec9b474279368e,0xbff1b28f50584fe3,3
+np.float64,0x3fe0139ca860273a,0x3fe0d7fc377f001c,3
+np.float64,0x3fdb080c9db61018,0x3fdbe85056358fa0,3
+np.float64,0xbfdd72ceb1bae59e,0xbfde99ea171661eb,3
+np.float64,0xbfe64e934fec9d26,0xbfe8aec2ef24be63,3
+np.float64,0x3fd1036a93a206d4,0x3fd1386adabe01bd,3
+np.float64,0x3febc9d4a5f793aa,0x3ff0d4c069f1e67d,3
+np.float64,0xbfe547a16fea8f43,0xbfe747902fe6fb4d,3
+np.float64,0x3fc289b0f9251360,0x3fc29a709de6bdd9,3
+np.float64,0xbfe694494a6d2892,0xbfe9108f3dc133e2,3
+np.float64,0x3fd827dfe4b04fc0,0x3fd8c4fe40532b91,3
+np.float64,0xbfe8b89418f17128,0xbfec400c5a334b2e,3
+np.float64,0x3fed5605147aac0a,0x3ff28ed1f612814a,3
+np.float64,0xbfed36af31fa6d5e,0xbff26804e1f71af0,3
+np.float64,0x3fdbb01c02b76038,0x3fdca2381558bbf0,3
+np.float64,0x3fe2a951666552a2,0x3fe3ec88f780f9e6,3
+np.float64,0x3fe662defbecc5be,0x3fe8cb1dbfca98ab,3
+np.float64,0x3fd098b1b3a13164,0x3fd0c9d064e4eaf2,3
+np.float64,0x3fefa10edeff421e,0x3ff6b1c6187b18a8,3
+np.float64,0xbfec4feb7a789fd7,0xbff16021ef37a219,3
+np.float64,0x3fd8e415bbb1c82c,0x3fd990c1f8b786bd,3
+np.float64,0xbfead5a09275ab41,0xbfefd44fab5b4f6e,3
+np.float64,0xbfe8666c16f0ccd8,0xbfebbfe0c9f2a9ae,3
+np.float64,0x3fdc962132b92c44,0x3fdda2525a6f406c,3
+np.float64,0xbfe2037f03e406fe,0xbfe3222ec2a3449e,3
+np.float64,0xbfec82c27e790585,0xbff197626ea9df1e,3
+np.float64,0x3fd2b4e03ca569c0,0x3fd2fbd3c7fda23e,3
+np.float64,0xbfe9b0dee5f361be,0xbfedd34f6d3dfe8a,3
+np.float64,0x3feef45cd17de8ba,0x3ff508180687b591,3
+np.float64,0x3f82c39bf0258700,0x3f82c3ad24c3b3f1,3
+np.float64,0xbfca848cfd350918,0xbfcab612ce258546,3
+np.float64,0x3fd6442aaaac8854,0x3fd6bdea54016e48,3
+np.float64,0x3fe550799e6aa0f4,0x3fe75369c9ea5b1e,3
+np.float64,0xbfe0e9d5a361d3ac,0xbfe1d20011139d89,3
+np.float64,0x3fbfc9ff1e3f9400,0x3fbfdf0ea6885c80,3
+np.float64,0xbfa187e8b4230fd0,0xbfa188c95072092e,3
+np.float64,0x3fcd28c9533a5190,0x3fcd6ae879c21b47,3
+np.float64,0x3fc6227ec52c4500,0x3fc63f1fbb441d29,3
+np.float64,0x3fe9b7a2ed736f46,0x3feddeab49b2d176,3
+np.float64,0x3fd4aee93da95dd4,0x3fd50fb3b71e0339,3
+np.float64,0xbfe164dacf62c9b6,0xbfe263bb2f7dd5d9,3
+np.float64,0x3fec62e525f8c5ca,0x3ff17496416d9921,3
+np.float64,0x3fdd363ee0ba6c7c,0x3fde55c6a49a5f86,3
+np.float64,0x3fe65cbf75ecb97e,0x3fe8c28d31ff3ebd,3
+np.float64,0xbfe76d27ca6eda50,0xbfea4899e3661425,3
+np.float64,0xbfc305738d260ae8,0xbfc3178dcfc9d30f,3
+np.float64,0xbfd3aa2a54a75454,0xbfd3fcf1e1ce8328,3
+np.float64,0x3fd1609fc9a2c140,0x3fd1992efa539b9f,3
+np.float64,0xbfac1291bc382520,0xbfac162cc7334b4d,3
+np.float64,0xbfedb461ea7b68c4,0xbff309247850455d,3
+np.float64,0xbfe8d2adf8f1a55c,0xbfec6947be90ba92,3
+np.float64,0xbfd7128965ae2512,0xbfd79a9855bcfc5a,3
+np.float64,0x3fe8deb09471bd62,0x3fec7c56b3aee531,3
+np.float64,0xbfe5f4d329ebe9a6,0xbfe8327ea8189af8,3
+np.float64,0xbfd3b46ac9a768d6,0xbfd407b80b12ff17,3
+np.float64,0x3fec899d7cf9133a,0x3ff19ef26baca36f,3
+np.float64,0xbfec192fd5783260,0xbff126306e507fd0,3
+np.float64,0x3fe945bdaef28b7c,0x3fed222f787310bf,3
+np.float64,0xbfeff9635d7ff2c7,0xbff87d6773f318eb,3
+np.float64,0xbfd604b81cac0970,0xbfd67a4aa852559a,3
+np.float64,0x3fcd1cc9d53a3990,0x3fcd5e962e237c24,3
+np.float64,0xbfed77b0fffaef62,0xbff2b97a1c9b6483,3
+np.float64,0xbfc9c69325338d28,0xbfc9f401500402fb,3
+np.float64,0xbfdf97e246bf2fc4,0xbfe0855601ea9db3,3
+np.float64,0x3fc7e6304f2fcc60,0x3fc80a4e718504cd,3
+np.float64,0x3fec3b599e7876b4,0x3ff14a2d1b9c68e6,3
+np.float64,0xbfe98618e1f30c32,0xbfed8bfbb31c394a,3
+np.float64,0xbfe59b3c0feb3678,0xbfe7b832d6df81de,3
+np.float64,0xbfe54ce2fe6a99c6,0xbfe74e9a85be4116,3
+np.float64,0x3fc9db49cb33b690,0x3fca092737ef500a,3
+np.float64,0xbfb4a922ae295248,0xbfb4aee4e39078a9,3
+np.float64,0xbfd0e542e0a1ca86,0xbfd11925208d66af,3
+np.float64,0x3fd70543f2ae0a88,0x3fd78c5e9238a3ee,3
+np.float64,0x3fd67f7a7facfef4,0x3fd6fd3998df8545,3
+np.float64,0xbfe40b643d6816c8,0xbfe5a947e427f298,3
+np.float64,0xbfcd85f69b3b0bec,0xbfcdcaa24b75f1a3,3
+np.float64,0x3fec705fb4f8e0c0,0x3ff1833c82163ee2,3
+np.float64,0x3fb37650ea26eca0,0x3fb37b20c16fb717,3
+np.float64,0x3fe5ebfa55ebd7f4,0x3fe826578d716e70,3
+np.float64,0x3fe991dfe5f323c0,0x3fed9f8a4bf1f588,3
+np.float64,0xbfd658bd0aacb17a,0xbfd6d3dd06e54900,3
+np.float64,0xbfc24860252490c0,0xbfc258701a0b9290,3
+np.float64,0xbfefb8d763ff71af,0xbff705b6ea4a569d,3
+np.float64,0x3fb8fcb4ae31f970,0x3fb906e809e7899f,3
+np.float64,0x3fce6343cb3cc688,0x3fceae41d1629625,3
+np.float64,0xbfd43d5a11a87ab4,0xbfd497da25687e07,3
+np.float64,0xbfe9568851f2ad11,0xbfed3d9e5fe83a76,3
+np.float64,0x3fe1b66153e36cc2,0x3fe2c53c7e016271,3
+np.float64,0x3fef27452bfe4e8a,0x3ff571b3486ed416,3
+np.float64,0x3fca87c0a7350f80,0x3fcab958a7bb82d4,3
+np.float64,0xbfd8776a8fb0eed6,0xbfd91afaf2f50edf,3
+np.float64,0x3fe9522a76f2a454,0x3fed3679264e1525,3
+np.float64,0x3fea14ff2cf429fe,0x3fee7da6431cc316,3
+np.float64,0x3fe970618bf2e0c4,0x3fed68154d54dd97,3
+np.float64,0x3fd3410cfca68218,0x3fd38e9b21792240,3
+np.float64,0xbf6a8070c0350100,0xbf6a8073c7c34517,3
+np.float64,0xbfbe449de23c8938,0xbfbe56c8e5e4d98b,3
+np.float64,0x3fedbc92e27b7926,0x3ff314313216d8e6,3
+np.float64,0xbfe3be4706677c8e,0xbfe546d3ceb85aea,3
+np.float64,0x3fe30cd6d76619ae,0x3fe467b6f2664a8d,3
+np.float64,0x3fd7d69b21afad38,0x3fd86d54284d05ad,3
+np.float64,0xbfe501001fea0200,0xbfe6e978afcff4d9,3
+np.float64,0xbfe44ba3d8e89748,0xbfe5fc0a31cd1e3e,3
+np.float64,0x3fec52f7c078a5f0,0x3ff16367acb209b2,3
+np.float64,0xbfcb19efcb3633e0,0xbfcb4ed9235a7d47,3
+np.float64,0xbfab86796c370cf0,0xbfab89df7bf15710,3
+np.float64,0xbfb962feda32c600,0xbfb96db1e1679c98,3
+np.float64,0x3fe0dd14e861ba2a,0x3fe1c2fc72810567,3
+np.float64,0x3fe41bcc6de83798,0x3fe5be59b7f9003b,3
+np.float64,0x3fc82f4c4f305e98,0x3fc854bd9798939f,3
+np.float64,0xbfcd143a613a2874,0xbfcd55cbd1619d84,3
+np.float64,0xbfd52da61baa5b4c,0xbfd595d0b3543439,3
+np.float64,0xbfb71b4a8e2e3698,0xbfb7235a4ab8432f,3
+np.float64,0xbfec141a19782834,0xbff120e1e39fc856,3
+np.float64,0xbfdba9319db75264,0xbfdc9a8ca2578bb2,3
+np.float64,0xbfbce5d74639cbb0,0xbfbcf5a4878cfa51,3
+np.float64,0x3fde67f7b3bccff0,0x3fdfaf45a9f843ad,3
+np.float64,0xbfe12d87bc625b10,0xbfe221fd4476eb71,3
+np.float64,0x3fe35b8f6be6b71e,0x3fe4ca20f65179e1,3
+np.float64,0xbfdbada1d3b75b44,0xbfdc9f78b19f93d1,3
+np.float64,0xbfc60159c52c02b4,0xbfc61d79b879f598,3
+np.float64,0x3fd6b81c38ad7038,0x3fd739c27bfa16d8,3
+np.float64,0xbfd646a253ac8d44,0xbfd6c08c19612bbb,3
+np.float64,0xbfe6babef0ed757e,0xbfe94703d0bfa311,3
+np.float64,0xbfed5671f1faace4,0xbff28f5a3f3683d0,3
+np.float64,0x3fc01d1e85203a40,0x3fc02817ec0dfd38,3
+np.float64,0xbfe9188a61f23115,0xbfecd8eb5da84223,3
+np.float64,0x3fdca3bab9b94774,0x3fddb1868660c239,3
+np.float64,0xbfa255750c24aaf0,0xbfa25675f7b36343,3
+np.float64,0x3fb3602db626c060,0x3fb364ed2d5b2876,3
+np.float64,0xbfd30a14bda6142a,0xbfd354ff703b8862,3
+np.float64,0xbfe1cfe381639fc7,0xbfe2e3e720b968c8,3
+np.float64,0xbfd2af6a4fa55ed4,0xbfd2f61e190bcd1f,3
+np.float64,0xbfe93c50937278a1,0xbfed12d64bb10d73,3
+np.float64,0x3fddd8bc44bbb178,0x3fdf0ced7f9005cc,3
+np.float64,0x3fdb2bc73cb65790,0x3fdc0fc0e18e425e,3
+np.float64,0xbfd073f6aba0e7ee,0xbfd0a3cb5468a961,3
+np.float64,0x3fed4bad7b7a975a,0x3ff281ebeb75e414,3
+np.float64,0xbfdc75b50bb8eb6a,0xbfdd7e1a7631cb22,3
+np.float64,0x3fd458a90fa8b154,0x3fd4b4a5817248ce,3
+np.float64,0x3feead5db57d5abc,0x3ff484286fab55ff,3
+np.float64,0x3fb3894382271280,0x3fb38e217b4e7905,3
+np.float64,0xffefffffffffffff,0x7ff8000000000000,3
+np.float64,0xbfe428212ae85042,0xbfe5ce36f226bea8,3
+np.float64,0xbfc08b39f7211674,0xbfc0971b93ebc7ad,3
+np.float64,0xbfc2e7cf5525cfa0,0xbfc2f994eb72b623,3
+np.float64,0xbfdb0d85afb61b0c,0xbfdbee5a2de3c5db,3
+np.float64,0xfff0000000000000,0x7ff8000000000000,3
+np.float64,0xbfd0d36af7a1a6d6,0xbfd106a5f05ef6ff,3
+np.float64,0xbfc333d0912667a0,0xbfc3467162b7289a,3
+np.float64,0x3fcdababc53b5758,0x3fcdf16458c20fa8,3
+np.float64,0x3fd0821b38a10438,0x3fd0b26e3e0b9185,3
+np.float64,0x0,0x0,3
+np.float64,0x3feb7f70edf6fee2,0x3ff08ae81854bf20,3
+np.float64,0x3fe6e075716dc0ea,0x3fe97cc5254be6ff,3
+np.float64,0x3fea13b682f4276e,0x3fee7b6f18073b5b,3

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-arcsinh.csv

@@ -0,0 +1,1429 @@
+dtype,input,output,ulperrortol
+np.float32,0xbf24142a,0xbf1a85ef,2
+np.float32,0x3e71cf91,0x3e6f9e37,2
+np.float32,0xe52a7,0xe52a7,2
+np.float32,0x3ef1e074,0x3ee9add9,2
+np.float32,0x806160ac,0x806160ac,2
+np.float32,0x7e2d59a2,0x42af4798,2
+np.float32,0xbf32cac9,0xbf26bf96,2
+np.float32,0x3f081701,0x3f026142,2
+np.float32,0x3f23cc88,0x3f1a499c,2
+np.float32,0xbf090d94,0xbf033ad0,2
+np.float32,0x803af2fc,0x803af2fc,2
+np.float32,0x807eb17e,0x807eb17e,2
+np.float32,0x5c0d8e,0x5c0d8e,2
+np.float32,0x3f7b79d2,0x3f5e6b1d,2
+np.float32,0x806feeae,0x806feeae,2
+np.float32,0x3e4b423a,0x3e49f274,2
+np.float32,0x3f49e5ac,0x3f394a41,2
+np.float32,0x3f18cd4e,0x3f10ef35,2
+np.float32,0xbed75734,0xbed17322,2
+np.float32,0x7f591151,0x42b28085,2
+np.float32,0xfefe9da6,0xc2b16f51,2
+np.float32,0xfeac90fc,0xc2b0a82a,2
+np.float32,0x805c198e,0x805c198e,2
+np.float32,0x7f66d6df,0x42b2a004,2
+np.float32,0x505438,0x505438,2
+np.float32,0xbf39a209,0xbf2c5255,2
+np.float32,0x7fa00000,0x7fe00000,2
+np.float32,0xc84cb,0xc84cb,2
+np.float32,0x7f07d6f5,0x42b19088,2
+np.float32,0x79d7e4,0x79d7e4,2
+np.float32,0xff32f6a0,0xc2b21db1,2
+np.float32,0x7c005c05,0x42a9222e,2
+np.float32,0x3ec449aa,0x3ebfc5ae,2
+np.float32,0x800ec323,0x800ec323,2
+np.float32,0xff1c904c,0xc2b1d93a,2
+np.float32,0x7f4eca52,0x42b267b0,2
+np.float32,0x3ee06540,0x3ed9c514,2
+np.float32,0x6aab4,0x6aab4,2
+np.float32,0x3e298d8c,0x3e28c99e,2
+np.float32,0xbf38d162,0xbf2ba94a,2
+np.float32,0x2d9083,0x2d9083,2
+np.float32,0x7eae5032,0x42b0ad52,2
+np.float32,0x3ead5b3c,0x3eaa3443,2
+np.float32,0x806fef66,0x806fef66,2
+np.float32,0x3f5b614e,0x3f46ca71,2
+np.float32,0xbf4c906a,0xbf3b60fc,2
+np.float32,0x8049453e,0x8049453e,2
+np.float32,0x3d305220,0x3d304432,2
+np.float32,0x2e1a89,0x2e1a89,2
+np.float32,0xbf4e74ec,0xbf3cdacf,2
+np.float32,0x807a827a,0x807a827a,2
+np.float32,0x80070745,0x80070745,2
+np.float32,0xbe1ba2fc,0xbe1b0b28,2
+np.float32,0xbe5131d0,0xbe4fc421,2
+np.float32,0x5bfd98,0x5bfd98,2
+np.float32,0xbd8e1a48,0xbd8dfd27,2
+np.float32,0x8006c160,0x8006c160,2
+np.float32,0x346490,0x346490,2
+np.float32,0xbdbdf060,0xbdbdaaf0,2
+np.float32,0x3ea9d0c4,0x3ea6d8c7,2
+np.float32,0xbf2aaa28,0xbf200916,2
+np.float32,0xbf160c26,0xbf0e9047,2
+np.float32,0x80081fd4,0x80081fd4,2
+np.float32,0x7db44283,0x42adf8b6,2
+np.float32,0xbf1983f8,0xbf118bf5,2
+np.float32,0x2c4a35,0x2c4a35,2
+np.float32,0x6165a7,0x6165a7,2
+np.float32,0xbe776b44,0xbe75129f,2
+np.float32,0xfe81841a,0xc2b0153b,2
+np.float32,0xbf7d1b2f,0xbf5f9461,2
+np.float32,0x80602d36,0x80602d36,2
+np.float32,0xfe8d5046,0xc2b041dd,2
+np.float32,0xfe5037bc,0xc2afa56d,2
+np.float32,0x4bbea6,0x4bbea6,2
+np.float32,0xfea039de,0xc2b0822d,2
+np.float32,0x7ea627a4,0x42b094c7,2
+np.float32,0x3f556198,0x3f423591,2
+np.float32,0xfedbae04,0xc2b123c1,2
+np.float32,0xbe30432c,0xbe2f6744,2
+np.float32,0x80202c77,0x80202c77,2
+np.float32,0xff335cc1,0xc2b21ed5,2
+np.float32,0x3e1e1ebe,0x3e1d7f95,2
+np.float32,0x8021c9c0,0x8021c9c0,2
+np.float32,0x7dc978,0x7dc978,2
+np.float32,0xff6cfabc,0xc2b2ad75,2
+np.float32,0x7f2bd542,0x42b208e0,2
+np.float32,0x53bf33,0x53bf33,2
+np.float32,0x804e04bb,0x804e04bb,2
+np.float32,0x3f30d2f9,0x3f2521ca,2
+np.float32,0x3dfde876,0x3dfd4316,2
+np.float32,0x46f8b1,0x46f8b1,2
+np.float32,0xbd5f9e20,0xbd5f81ba,2
+np.float32,0x807d6a22,0x807d6a22,2
+np.float32,0xff3881da,0xc2b22d50,2
+np.float32,0x1b1cb5,0x1b1cb5,2
+np.float32,0x3f75f2d0,0x3f5a7435,2
+np.float32,0xfee39c1a,0xc2b135e9,2
+np.float32,0x7f79f14a,0x42b2c8b9,2
+np.float32,0x8000e2d1,0x8000e2d1,2
+np.float32,0xab779,0xab779,2
+np.float32,0xbede6690,0xbed7f102,2
+np.float32,0x76e20d,0x76e20d,2
+np.float32,0x3ed714cb,0x3ed135e9,2
+np.float32,0xbeaa6f44,0xbea76f31,2
+np.float32,0x7f7dc8b1,0x42b2d089,2
+np.float32,0x108cb2,0x108cb2,2
+np.float32,0x7d37ba82,0x42ac9f94,2
+np.float32,0x3f31d068,0x3f25f221,2
+np.float32,0x8010a331,0x8010a331,2
+np.float32,0x3f2fdc7c,0x3f2456cd,2
+np.float32,0x7f7a9a67,0x42b2ca13,2
+np.float32,0x3f2acb31,0x3f202492,2
+np.float32,0x7f54fa94,0x42b276c9,2
+np.float32,0x3ebf8a70,0x3ebb553c,2
+np.float32,0x7f75b1a7,0x42b2bff2,2
+np.float32,0x7daebe07,0x42ade8cc,2
+np.float32,0xbd3a3ef0,0xbd3a2e86,2
+np.float32,0x8078ec9e,0x8078ec9e,2
+np.float32,0x3eda206a,0x3ed403ec,2
+np.float32,0x3f7248f2,0x3f57cd77,2
+np.float32,0x805d55ba,0x805d55ba,2
+np.float32,0xff30dc3e,0xc2b217a3,2
+np.float32,0xbe12b27c,0xbe123333,2
+np.float32,0xbf6ed9cf,0xbf554cd0,2
+np.float32,0xbed9eb5c,0xbed3d31c,2
+np.float32,0xbf1c9aea,0xbf14307b,2
+np.float32,0x3f540ac4,0x3f412de2,2
+np.float32,0x800333ac,0x800333ac,2
+np.float32,0x3f74cdb4,0x3f59a09a,2
+np.float32,0xbf41dc41,0xbf32ee6f,2
+np.float32,0xff2c7804,0xc2b20ac4,2
+np.float32,0x514493,0x514493,2
+np.float32,0xbddf1220,0xbddea1cf,2
+np.float32,0xfeaf74de,0xc2b0b0ab,2
+np.float32,0xfe5dfb30,0xc2afc633,2
+np.float32,0xbf4785c4,0xbf376bdb,2
+np.float32,0x80191cd3,0x80191cd3,2
+np.float32,0xfe44f708,0xc2af88fb,2
+np.float32,0x3d4cd8a0,0x3d4cc2ca,2
+np.float32,0x7f572eff,0x42b27c0f,2
+np.float32,0x8031bacb,0x8031bacb,2
+np.float32,0x7f2ea684,0x42b21133,2
+np.float32,0xbea1976a,0xbe9f05bb,2
+np.float32,0x3d677b41,0x3d675bc1,2
+np.float32,0x3f61bf24,0x3f4b9870,2
+np.float32,0x7ef55ddf,0x42b15c5f,2
+np.float32,0x3eabcb20,0x3ea8b91c,2
+np.float32,0xff73d9ec,0xc2b2bc18,2
+np.float32,0x77b9f5,0x77b9f5,2
+np.float32,0x4c6c6c,0x4c6c6c,2
+np.float32,0x7ed09c94,0x42b10949,2
+np.float32,0xdeeec,0xdeeec,2
+np.float32,0x7eac5858,0x42b0a782,2
+np.float32,0x7e190658,0x42af07bd,2
+np.float32,0xbe3c8980,0xbe3b7ce2,2
+np.float32,0x8059e86e,0x8059e86e,2
+np.float32,0xff201836,0xc2b1e4a5,2
+np.float32,0xbeac109c,0xbea8fafb,2
+np.float32,0x7edd1e2b,0x42b12718,2
+np.float32,0x639cd8,0x639cd8,2
+np.float32,0x3f5e4cae,0x3f490059,2
+np.float32,0x3d84c185,0x3d84a9c4,2
+np.float32,0xbe8c1130,0xbe8a605b,2
+np.float32,0x80000000,0x80000000,2
+np.float32,0x3f1da5e4,0x3f151404,2
+np.float32,0x7f75a873,0x42b2bfdf,2
+np.float32,0xbd873540,0xbd871c28,2
+np.float32,0xbe8e5e10,0xbe8c9808,2
+np.float32,0x7f004bf2,0x42b17347,2
+np.float32,0x800000,0x800000,2
+np.float32,0xbf6d6b79,0xbf544095,2
+np.float32,0x7ed7b563,0x42b11a6a,2
+np.float32,0x80693745,0x80693745,2
+np.float32,0x3ee0f608,0x3eda49a8,2
+np.float32,0xfe1285a4,0xc2aef181,2
+np.float32,0x72d946,0x72d946,2
+np.float32,0x6a0dca,0x6a0dca,2
+np.float32,0x3f5c9df6,0x3f47ba99,2
+np.float32,0xff002af6,0xc2b172c4,2
+np.float32,0x3f4ac98f,0x3f39fd0a,2
+np.float32,0x8066acf7,0x8066acf7,2
+np.float32,0xbcaa4e60,0xbcaa4b3c,2
+np.float32,0x80162813,0x80162813,2
+np.float32,0xff34b318,0xc2b222a2,2
+np.float32,0x7f1ce33c,0x42b1da49,2
+np.float32,0x3f0e55ab,0x3f07ddb0,2
+np.float32,0x7c75d996,0x42aa6eec,2
+np.float32,0xbf221bc6,0xbf18dc89,2
+np.float32,0x3f5a1a4c,0x3f45d1d4,2
+np.float32,0x7f2451b8,0x42b1f1fb,2
+np.float32,0x3ec55ca0,0x3ec0c655,2
+np.float32,0x3f752dc2,0x3f59e600,2
+np.float32,0xbe33f638,0xbe330c4d,2
+np.float32,0x3e2a9148,0x3e29c9d8,2
+np.float32,0x3f3362a1,0x3f273c01,2
+np.float32,0x5f83b3,0x5f83b3,2
+np.float32,0x3e362488,0x3e353216,2
+np.float32,0x140bcf,0x140bcf,2
+np.float32,0x7e3e96df,0x42af7822,2
+np.float32,0xbebc7082,0xbeb86ce6,2
+np.float32,0xbe92a92e,0xbe90b9d2,2
+np.float32,0xff3d8afc,0xc2b23b19,2
+np.float32,0x804125e3,0x804125e3,2
+np.float32,0x3f3675d1,0x3f29bedb,2
+np.float32,0xff70bb09,0xc2b2b57f,2
+np.float32,0x3f29681c,0x3f1efcd2,2
+np.float32,0xbdc70380,0xbdc6b3a8,2
+np.float32,0x54e0dd,0x54e0dd,2
+np.float32,0x3d545de0,0x3d54458c,2
+np.float32,0x7f800000,0x7f800000,2
+np.float32,0x8014a4c2,0x8014a4c2,2
+np.float32,0xbe93f58a,0xbe91f938,2
+np.float32,0x17de33,0x17de33,2
+np.float32,0xfefb679a,0xc2b168d2,2
+np.float32,0xbf23423e,0xbf19d511,2
+np.float32,0x7e893fa1,0x42b032ec,2
+np.float32,0x3f44fe2d,0x3f356bda,2
+np.float32,0xbebb2e78,0xbeb73e8f,2
+np.float32,0x3f5632e0,0x3f42d633,2
+np.float32,0x3ddd8698,0x3ddd1896,2
+np.float32,0x80164ea7,0x80164ea7,2
+np.float32,0x80087b37,0x80087b37,2
+np.float32,0xbf06ab1e,0xbf011f95,2
+np.float32,0x3db95524,0x3db9149f,2
+np.float32,0x7aa1fbb3,0x42a570a1,2
+np.float32,0xbd84fc48,0xbd84e467,2
+np.float32,0x3d65c6f5,0x3d65a826,2
+np.float32,0xfe987800,0xc2b068c4,2
+np.float32,0x7ec59532,0x42b0ed7a,2
+np.float32,0x3ea0232c,0x3e9da29a,2
+np.float32,0x80292a08,0x80292a08,2
+np.float32,0x734cfe,0x734cfe,2
+np.float32,0x3f3b6d63,0x3f2dc596,2
+np.float32,0x3f27bcc1,0x3f1d97e6,2
+np.float32,0xfe1da554,0xc2af16f9,2
+np.float32,0x7c91f5,0x7c91f5,2
+np.float32,0xfe4e78cc,0xc2afa11e,2
+np.float32,0x7e4b4e08,0x42af9933,2
+np.float32,0xfe0949ec,0xc2aed02e,2
+np.float32,0x7e2f057f,0x42af4c81,2
+np.float32,0xbf200ae0,0xbf171ce1,2
+np.float32,0x3ebcc244,0x3eb8b99e,2
+np.float32,0xbf68f58d,0xbf50f7aa,2
+np.float32,0x4420b1,0x4420b1,2
+np.float32,0x3f5b61bf,0x3f46cac7,2
+np.float32,0x3fec78,0x3fec78,2
+np.float32,0x7f4183c8,0x42b245b7,2
+np.float32,0xbf10587c,0xbf099ee2,2
+np.float32,0x0,0x0,2
+np.float32,0x7ec84dc3,0x42b0f47a,2
+np.float32,0x3f5fbd7b,0x3f4a166d,2
+np.float32,0xbd884eb8,0xbd883502,2
+np.float32,0xfe3f10a4,0xc2af7969,2
+np.float32,0xff3f4920,0xc2b23fc9,2
+np.float32,0x8013900f,0x8013900f,2
+np.float32,0x8003529d,0x8003529d,2
+np.float32,0xbf032384,0xbefbfb3c,2
+np.float32,0xff418c7c,0xc2b245ce,2
+np.float32,0xbec0aad0,0xbebc633b,2
+np.float32,0xfdbff178,0xc2ae18de,2
+np.float32,0x68ab15,0x68ab15,2
+np.float32,0xbdfc4a88,0xbdfba848,2
+np.float32,0xbf5adec6,0xbf466747,2
+np.float32,0x807d5dcc,0x807d5dcc,2
+np.float32,0x61d144,0x61d144,2
+np.float32,0x807e3a03,0x807e3a03,2
+np.float32,0x1872f2,0x1872f2,2
+np.float32,0x7f2a272c,0x42b203d8,2
+np.float32,0xfe7f8314,0xc2b00e3a,2
+np.float32,0xbe42aeac,0xbe418737,2
+np.float32,0x8024b614,0x8024b614,2
+np.float32,0xbe41b6b8,0xbe40939a,2
+np.float32,0xa765c,0xa765c,2
+np.float32,0x7ea74f4b,0x42b09853,2
+np.float32,0x7f7ef631,0x42b2d2e7,2
+np.float32,0x7eaef5e6,0x42b0af38,2
+np.float32,0xff733d85,0xc2b2bacf,2
+np.float32,0x537ac0,0x537ac0,2
+np.float32,0xbeca4790,0xbec55b1d,2
+np.float32,0x80117314,0x80117314,2
+np.float32,0xfe958536,0xc2b05ec5,2
+np.float32,0x8066ecc2,0x8066ecc2,2
+np.float32,0xbf56baf3,0xbf433e82,2
+np.float32,0x1f7fd7,0x1f7fd7,2
+np.float32,0x3e942104,0x3e9222fc,2
+np.float32,0xfeaffe82,0xc2b0b23c,2
+np.float32,0xfe0e02b0,0xc2aee17e,2
+np.float32,0xbf800000,0xbf61a1b3,2
+np.float32,0x800b7e49,0x800b7e49,2
+np.float32,0x6c514f,0x6c514f,2
+np.float32,0xff800000,0xff800000,2
+np.float32,0x7f7d9a45,0x42b2d02b,2
+np.float32,0x800c9c69,0x800c9c69,2
+np.float32,0x274b14,0x274b14,2
+np.float32,0xbf4b22b0,0xbf3a42e2,2
+np.float32,0x63e5ae,0x63e5ae,2
+np.float32,0xbe18facc,0xbe186a90,2
+np.float32,0x7e137351,0x42aef4bd,2
+np.float32,0x80518ffd,0x80518ffd,2
+np.float32,0xbf0a8ffc,0xbf048f0d,2
+np.float32,0x841d,0x841d,2
+np.float32,0x7edfdc9e,0x42b12d69,2
+np.float32,0xfd1092b0,0xc2ac24de,2
+np.float32,0x7e2c9bdf,0x42af4566,2
+np.float32,0x7f7fffff,0x42b2d4fc,2
+np.float32,0x3f4954a6,0x3f38d853,2
+np.float32,0xbe83efd2,0xbe8284c3,2
+np.float32,0x800e8e02,0x800e8e02,2
+np.float32,0x78ad39,0x78ad39,2
+np.float32,0x7eb0f967,0x42b0b514,2
+np.float32,0xbe39aa94,0xbe38a9ee,2
+np.float32,0x80194e7b,0x80194e7b,2
+np.float32,0x3cf3a340,0x3cf39a0f,2
+np.float32,0x3ed3117a,0x3ecd8173,2
+np.float32,0x7f530b11,0x42b2721c,2
+np.float32,0xff756ba2,0xc2b2bf60,2
+np.float32,0x15ea25,0x15ea25,2
+np.float32,0x803cbb64,0x803cbb64,2
+np.float32,0x3f34722d,0x3f281a2c,2
+np.float32,0x3ddd88e0,0x3ddd1adb,2
+np.float32,0x3f54244c,0x3f41418b,2
+np.float32,0x3e0adb98,0x3e0a6f8b,2
+np.float32,0x80800000,0x80800000,2
+np.float32,0x58902b,0x58902b,2
+np.float32,0xfe3b50b8,0xc2af6f43,2
+np.float32,0xfe0846d0,0xc2aecc64,2
+np.float32,0xbe0299d0,0xbe023fd4,2
+np.float32,0x18dde6,0x18dde6,2
+np.float32,0x8039fe8b,0x8039fe8b,2
+np.float32,0x8015d179,0x8015d179,2
+np.float32,0x3f551322,0x3f41f947,2
+np.float32,0x2ab387,0x2ab387,2
+np.float32,0xbf7e311e,0xbf6059d0,2
+np.float32,0xbdba58a8,0xbdba1713,2
+np.float32,0xbf1d008a,0xbf148724,2
+np.float32,0xbf6b9c97,0xbf52ec98,2
+np.float32,0x802acf04,0x802acf04,2
+np.float32,0x1,0x1,2
+np.float32,0xbe9e16d6,0xbe9bade3,2
+np.float32,0xbf048a14,0xbefe78c7,2
+np.float32,0x7e432ad3,0x42af8449,2
+np.float32,0xbdcc7fe0,0xbdcc2944,2
+np.float32,0x6dfc27,0x6dfc27,2
+np.float32,0xfef6eed8,0xc2b15fa1,2
+np.float32,0xbeeff6e8,0xbee7f2e4,2
+np.float32,0x7e3a6ca8,0x42af6cd2,2
+np.float32,0xff2c82e8,0xc2b20ae4,2
+np.float32,0x3e9f8d74,0x3e9d13b0,2
+np.float32,0x7ea36191,0x42b08c29,2
+np.float32,0x7f734bed,0x42b2baed,2
+np.float32,0x7f2df96d,0x42b20f37,2
+np.float32,0x5036fd,0x5036fd,2
+np.float32,0x806eab38,0x806eab38,2
+np.float32,0xbe9db90e,0xbe9b5446,2
+np.float32,0xfeef6fac,0xc2b14fd9,2
+np.float32,0xc2bf7,0xc2bf7,2
+np.float32,0xff53ec3d,0xc2b2743d,2
+np.float32,0x7e837637,0x42b01cde,2
+np.float32,0xbefb5934,0xbef23662,2
+np.float32,0x3f6cec80,0x3f53e371,2
+np.float32,0x3e86e7de,0x3e85643f,2
+np.float32,0x3f09cb42,0x3f03e1ef,2
+np.float32,0xbec3d236,0xbebf5620,2
+np.float32,0xfedef246,0xc2b12b50,2
+np.float32,0xbf08d6a8,0xbf030a62,2
+np.float32,0x8036cbf9,0x8036cbf9,2
+np.float32,0x3f74d3e3,0x3f59a512,2
+np.float32,0x6a600c,0x6a600c,2
+np.float32,0xfd1295b0,0xc2ac2bf1,2
+np.float32,0xbeb61142,0xbeb26efa,2
+np.float32,0x80216556,0x80216556,2
+np.float32,0xbf1fa0f6,0xbf16c30a,2
+np.float32,0x3e0af8e1,0x3e0a8c90,2
+np.float32,0x80434709,0x80434709,2
+np.float32,0x49efd9,0x49efd9,2
+np.float32,0x7f7cce6c,0x42b2ce8f,2
+np.float32,0x6e5450,0x6e5450,2
+np.float32,0x7f0fc115,0x42b1ad86,2
+np.float32,0x632db0,0x632db0,2
+np.float32,0x3f6f4c2a,0x3f55a064,2
+np.float32,0x7ec4f273,0x42b0ebd3,2
+np.float32,0x61ae1e,0x61ae1e,2
+np.float32,0x5f47c4,0x5f47c4,2
+np.float32,0xbf3c8f62,0xbf2eaf54,2
+np.float32,0xfca38900,0xc2ab0113,2
+np.float32,0x3ec89d52,0x3ec3ce78,2
+np.float32,0xbe0e3f70,0xbe0dcb53,2
+np.float32,0x805d3156,0x805d3156,2
+np.float32,0x3eee33f8,0x3ee65a4e,2
+np.float32,0xbeda7e9a,0xbed45a90,2
+np.float32,0x7e2fac7b,0x42af4e69,2
+np.float32,0x7efd0e28,0x42b16c2c,2
+np.float32,0x3f0c7b17,0x3f063e46,2
+np.float32,0xbf395bec,0xbf2c198f,2
+np.float32,0xfdf1c3f8,0xc2ae8f05,2
+np.float32,0xbe11f4e4,0xbe117783,2
+np.float32,0x7eddc901,0x42b128a3,2
+np.float32,0x3f4bad09,0x3f3aaf33,2
+np.float32,0xfefb5d76,0xc2b168bd,2
+np.float32,0x3ed3a4cf,0x3ece09a3,2
+np.float32,0x7ec582e4,0x42b0ed4a,2
+np.float32,0x3dc2268a,0x3dc1dc64,2
+np.float32,0x3ef9b17c,0x3ef0b9c9,2
+np.float32,0x2748ac,0x2748ac,2
+np.float32,0xfed6a602,0xc2b117e4,2
+np.float32,0xbefc9c36,0xbef35832,2
+np.float32,0x7e0476,0x7e0476,2
+np.float32,0x804be1a0,0x804be1a0,2
+np.float32,0xbefbc1c2,0xbef2943a,2
+np.float32,0xbd4698f0,0xbd46850a,2
+np.float32,0x688627,0x688627,2
+np.float32,0x3f7f7685,0x3f61406f,2
+np.float32,0x827fb,0x827fb,2
+np.float32,0x3f503264,0x3f3e34fd,2
+np.float32,0x7f5458d1,0x42b27543,2
+np.float32,0x800ac01f,0x800ac01f,2
+np.float32,0x6188dd,0x6188dd,2
+np.float32,0x806ac0ba,0x806ac0ba,2
+np.float32,0xbe14493c,0xbe13c5cc,2
+np.float32,0x3f77542c,0x3f5b72ae,2
+np.float32,0xfeaacab6,0xc2b0a2df,2
+np.float32,0x7f2893d5,0x42b1ff15,2
+np.float32,0x66b528,0x66b528,2
+np.float32,0xbf653e24,0xbf4e3573,2
+np.float32,0x801a2853,0x801a2853,2
+np.float32,0x3f3d8c98,0x3f2f7b04,2
+np.float32,0xfdffbad8,0xc2aeabc5,2
+np.float32,0x3dd50f,0x3dd50f,2
+np.float32,0x3f325a4c,0x3f266353,2
+np.float32,0xfcc48ec0,0xc2ab5f3f,2
+np.float32,0x3e6f5b9a,0x3e6d3ae5,2
+np.float32,0x3dbcd62b,0x3dbc91ee,2
+np.float32,0xbf7458d9,0xbf594c1c,2
+np.float32,0xff5adb24,0xc2b284b9,2
+np.float32,0x807b246d,0x807b246d,2
+np.float32,0x3f800000,0x3f61a1b3,2
+np.float32,0x231a28,0x231a28,2
+np.float32,0xbdc66258,0xbdc61341,2
+np.float32,0x3c84b4b4,0x3c84b338,2
+np.float32,0xbf215894,0xbf183783,2
+np.float32,0xff4ee298,0xc2b267ec,2
+np.float32,0x801ef52e,0x801ef52e,2
+np.float32,0x1040b0,0x1040b0,2
+np.float32,0xff545582,0xc2b2753b,2
+np.float32,0x3f3b9dda,0x3f2decaf,2
+np.float32,0x730f99,0x730f99,2
+np.float32,0xff7fffff,0xc2b2d4fc,2
+np.float32,0xff24cc5e,0xc2b1f379,2
+np.float32,0xbe9b456a,0xbe98fc0b,2
+np.float32,0x188fb,0x188fb,2
+np.float32,0x3f5c7ce2,0x3f47a18a,2
+np.float32,0x7fc00000,0x7fc00000,2
+np.float32,0x806ea4da,0x806ea4da,2
+np.float32,0xfe810570,0xc2b01345,2
+np.float32,0x8036af89,0x8036af89,2
+np.float32,0x8043cec6,0x8043cec6,2
+np.float32,0x80342bb3,0x80342bb3,2
+np.float32,0x1a2bd4,0x1a2bd4,2
+np.float32,0x3f6248c2,0x3f4bff9a,2
+np.float32,0x8024eb35,0x8024eb35,2
+np.float32,0x7ea55872,0x42b09247,2
+np.float32,0x806d6e56,0x806d6e56,2
+np.float32,0x25c21a,0x25c21a,2
+np.float32,0x3f4e95f3,0x3f3cf483,2
+np.float32,0x15ca38,0x15ca38,2
+np.float32,0x803f01b2,0x803f01b2,2
+np.float32,0xbe731634,0xbe70dc10,2
+np.float32,0x3e80cee4,0x3e7ef933,2
+np.float32,0x3ef6dda5,0x3eee2e7b,2
+np.float32,0x3f3dfdc2,0x3f2fd5ed,2
+np.float32,0xff0492a7,0xc2b18411,2
+np.float32,0xbf1d0adf,0xbf148ff3,2
+np.float32,0xfcf75460,0xc2abd4e3,2
+np.float32,0x3f46fca6,0x3f36ffa6,2
+np.float32,0xbe63b5c0,0xbe61dfb3,2
+np.float32,0xff019bec,0xc2b1787d,2
+np.float32,0x801f14a9,0x801f14a9,2
+np.float32,0x3f176cfa,0x3f0fc051,2
+np.float32,0x3f69d976,0x3f51a015,2
+np.float32,0x3f4917cb,0x3f38a87a,2
+np.float32,0x3b2a0bea,0x3b2a0bdd,2
+np.float32,0xbf41d857,0xbf32eb50,2
+np.float32,0xbf08841a,0xbf02c18f,2
+np.float32,0x7ec86f14,0x42b0f4d0,2
+np.float32,0xbf7d15d1,0xbf5f9090,2
+np.float32,0xbd080550,0xbd07feea,2
+np.float32,0xbf6f1bef,0xbf557d26,2
+np.float32,0xfebc282c,0xc2b0d473,2
+np.float32,0x3e68d2f5,0x3e66dd03,2
+np.float32,0x3f3ed8fe,0x3f3085d5,2
+np.float32,0xff2f78ae,0xc2b2139a,2
+np.float32,0xff647a70,0xc2b29ac1,2
+np.float32,0xfd0859a0,0xc2ac06e2,2
+np.float32,0x3ea578a8,0x3ea2b7e1,2
+np.float32,0x6c58c6,0x6c58c6,2
+np.float32,0xff23f26a,0xc2b1f0d2,2
+np.float32,0x800902a4,0x800902a4,2
+np.float32,0xfe8ba64e,0xc2b03bcd,2
+np.float32,0x3f091143,0x3f033e0f,2
+np.float32,0x8017c4bd,0x8017c4bd,2
+np.float32,0xbf708fd4,0xbf568c8c,2
+np.float32,0x3be1d8,0x3be1d8,2
+np.float32,0x80091f07,0x80091f07,2
+np.float32,0x68eabe,0x68eabe,2
+np.float32,0xfe9ab2c8,0xc2b07033,2
+np.float32,0x3eabe752,0x3ea8d3d7,2
+np.float32,0xbf7adcb2,0xbf5dfaf5,2
+np.float32,0x801ecc01,0x801ecc01,2
+np.float32,0xbf5570a9,0xbf424123,2
+np.float32,0x3e89eecd,0x3e88510e,2
+np.float32,0xfeb2feee,0xc2b0bae4,2
+np.float32,0xbeb25ec2,0xbeaef22b,2
+np.float32,0x201e49,0x201e49,2
+np.float32,0x800a35f6,0x800a35f6,2
+np.float32,0xbf02d449,0xbefb6e2a,2
+np.float32,0x3f062bea,0x3f00aef6,2
+np.float32,0x7f5219ff,0x42b26fd2,2
+np.float32,0xbd4561d0,0xbd454e47,2
+np.float32,0x3f6c4789,0x3f536a4b,2
+np.float32,0x7f58b06d,0x42b27fa1,2
+np.float32,0x7f132f39,0x42b1b999,2
+np.float32,0x3e05dcb4,0x3e057bd8,2
+np.float32,0x7f526045,0x42b2707d,2
+np.float32,0x3f6117d0,0x3f4b1adb,2
+np.float32,0xbf21f47d,0xbf18bb57,2
+np.float32,0x1a26d6,0x1a26d6,2
+np.float32,0x46b114,0x46b114,2
+np.float32,0x3eb24518,0x3eaed9ef,2
+np.float32,0xfe2139c8,0xc2af2278,2
+np.float32,0xbf7c36fb,0xbf5ef1f6,2
+np.float32,0x3f193834,0x3f114af7,2
+np.float32,0xff3ea650,0xc2b23e14,2
+np.float32,0xfeeb3bca,0xc2b146c7,2
+np.float32,0x7e8b8ca0,0x42b03b6f,2
+np.float32,0x3eed903d,0x3ee5c5d2,2
+np.float32,0xbdc73740,0xbdc6e72a,2
+np.float32,0x7e500307,0x42afa4ec,2
+np.float32,0xe003c,0xe003c,2
+np.float32,0x3e612bb4,0x3e5f64fd,2
+np.float32,0xfd81e248,0xc2ad50e6,2
+np.float32,0x766a4f,0x766a4f,2
+np.float32,0x3e8708c9,0x3e858414,2
+np.float32,0xbf206c58,0xbf176f7f,2
+np.float32,0x7e93aeb0,0x42b0586f,2
+np.float32,0xfd9d36b8,0xc2adb2ad,2
+np.float32,0xff1f4e0e,0xc2b1e21d,2
+np.float32,0x3f22bd5a,0x3f1964f8,2
+np.float32,0x7f6a517a,0x42b2a7ad,2
+np.float32,0xff6ca773,0xc2b2acc1,2
+np.float32,0x7f6bf453,0x42b2ab3d,2
+np.float32,0x3edfdd64,0x3ed9489f,2
+np.float32,0xbeafc5ba,0xbeac7daa,2
+np.float32,0x7d862039,0x42ad615b,2
+np.float32,0xbe9d2002,0xbe9ac1fc,2
+np.float32,0xbdcc54c0,0xbdcbfe5b,2
+np.float32,0xbf1bc0aa,0xbf13762a,2
+np.float32,0xbf4679ce,0xbf36984b,2
+np.float32,0x3ef45696,0x3eebe713,2
+np.float32,0xff6eb999,0xc2b2b137,2
+np.float32,0xbe4b2e4c,0xbe49dee8,2
+np.float32,0x3f498951,0x3f3901b7,2
+np.float32,0xbe9692f4,0xbe947be1,2
+np.float32,0xbf44ce26,0xbf3545c8,2
+np.float32,0x805787a8,0x805787a8,2
+np.float32,0xbf342650,0xbf27dc26,2
+np.float32,0x3edafbf0,0x3ed4cdd2,2
+np.float32,0x3f6fb858,0x3f55ef63,2
+np.float32,0xff227d0a,0xc2b1ec3f,2
+np.float32,0xfeb9a202,0xc2b0cd89,2
+np.float32,0x7f5b12c1,0x42b2853b,2
+np.float32,0x584578,0x584578,2
+np.float32,0x7ec0b76f,0x42b0e0b5,2
+np.float32,0x3f57f54b,0x3f442f10,2
+np.float32,0x7eef3620,0x42b14f5d,2
+np.float32,0x4525b5,0x4525b5,2
+np.float32,0x801bd407,0x801bd407,2
+np.float32,0xbed1f166,0xbecc7703,2
+np.float32,0x3f57e732,0x3f442449,2
+np.float32,0x80767cd5,0x80767cd5,2
+np.float32,0xbef1a7d2,0xbee97aa3,2
+np.float32,0x3dd5b1af,0x3dd54ee6,2
+np.float32,0x960c,0x960c,2
+np.float32,0x7c392d41,0x42a9ddd1,2
+np.float32,0x3f5c9a34,0x3f47b7c1,2
+np.float32,0x3f5cecee,0x3f47f667,2
+np.float32,0xbee482ce,0xbedd8899,2
+np.float32,0x8066ba7e,0x8066ba7e,2
+np.float32,0x7ed76127,0x42b119a2,2
+np.float32,0x805ca40b,0x805ca40b,2
+np.float32,0x7f5ed5d1,0x42b28df3,2
+np.float32,0xfe9e1b1e,0xc2b07b5b,2
+np.float32,0x3f0201a2,0x3ef9f6c4,2
+np.float32,0xbf2e6430,0xbf232039,2
+np.float32,0x80326b4d,0x80326b4d,2
+np.float32,0x3f11dc7c,0x3f0af06e,2
+np.float32,0xbe89c42e,0xbe8827e6,2
+np.float32,0x3f3c69f8,0x3f2e9133,2
+np.float32,0x806326a9,0x806326a9,2
+np.float32,0x3f1c5286,0x3f13f2b6,2
+np.float32,0xff5c0ead,0xc2b28786,2
+np.float32,0xff32b952,0xc2b21d01,2
+np.float32,0x7dd27c4e,0x42ae4815,2
+np.float32,0xbf7a6816,0xbf5da7a2,2
+np.float32,0xfeac72f8,0xc2b0a7d1,2
+np.float32,0x335ad7,0x335ad7,2
+np.float32,0xbe682da4,0xbe663bcc,2
+np.float32,0x3f2df244,0x3f22c208,2
+np.float32,0x80686e8e,0x80686e8e,2
+np.float32,0x7f50120f,0x42b26ad9,2
+np.float32,0x3dbc596a,0x3dbc15b3,2
+np.float32,0xbf4f2868,0xbf3d666d,2
+np.float32,0x80000001,0x80000001,2
+np.float32,0xff66c059,0xc2b29fd2,2
+np.float32,0xfe8bbcaa,0xc2b03c1f,2
+np.float32,0x3ece6a51,0x3ec93271,2
+np.float32,0x7f06cd26,0x42b18c9a,2
+np.float32,0x7e41e6dc,0x42af80f5,2
+np.float32,0x7d878334,0x42ad669f,2
+np.float32,0xfe8c5c4c,0xc2b03e67,2
+np.float32,0x337a05,0x337a05,2
+np.float32,0x3e63801d,0x3e61ab58,2
+np.float32,0x62c315,0x62c315,2
+np.float32,0x802aa888,0x802aa888,2
+np.float32,0x80038b43,0x80038b43,2
+np.float32,0xff5c1271,0xc2b2878f,2
+np.float32,0xff4184a5,0xc2b245b9,2
+np.float32,0x7ef58f4b,0x42b15cc6,2
+np.float32,0x7f42d8ac,0x42b2493a,2
+np.float32,0x806609f2,0x806609f2,2
+np.float32,0x801e763b,0x801e763b,2
+np.float32,0x7f2bc073,0x42b208a2,2
+np.float32,0x801d7d7f,0x801d7d7f,2
+np.float32,0x7d415dc1,0x42acb9c2,2
+np.float32,0xbf624ff9,0xbf4c0502,2
+np.float32,0xbf603afd,0xbf4a74e2,2
+np.float32,0x8007fe42,0x8007fe42,2
+np.float32,0x800456db,0x800456db,2
+np.float32,0x620871,0x620871,2
+np.float32,0x3e9c6c1e,0x3e9a15fa,2
+np.float32,0x4245d,0x4245d,2
+np.float32,0x8035bde9,0x8035bde9,2
+np.float32,0xbf597418,0xbf45533c,2
+np.float32,0x3c730f80,0x3c730d38,2
+np.float32,0x3f7cd8ed,0x3f5f6540,2
+np.float32,0x807e49c3,0x807e49c3,2
+np.float32,0x3d6584c0,0x3d65660c,2
+np.float32,0xff42a744,0xc2b248b8,2
+np.float32,0xfedc6f56,0xc2b12583,2
+np.float32,0x806263a4,0x806263a4,2
+np.float32,0x175a17,0x175a17,2
+np.float32,0x3f1e8537,0x3f15d208,2
+np.float32,0x4055b5,0x4055b5,2
+np.float32,0x438aa6,0x438aa6,2
+np.float32,0x8038507f,0x8038507f,2
+np.float32,0xbed75348,0xbed16f85,2
+np.float32,0x7f07b7d6,0x42b19012,2
+np.float32,0xfe8b9d30,0xc2b03bac,2
+np.float32,0x805c501c,0x805c501c,2
+np.float32,0x3ef22b1d,0x3ee9f159,2
+np.float32,0x802b6759,0x802b6759,2
+np.float32,0x45281a,0x45281a,2
+np.float32,0xbf7e9970,0xbf60a3cf,2
+np.float32,0xbf14d152,0xbf0d8062,2
+np.float32,0x3d9ff950,0x3d9fcfc8,2
+np.float32,0x7865d9,0x7865d9,2
+np.float32,0xbee67fa4,0xbedf58eb,2
+np.float32,0x7dc822d1,0x42ae2e44,2
+np.float32,0x3f3af0fe,0x3f2d612c,2
+np.float32,0xbefea106,0xbef5274e,2
+np.float32,0xbf758a3f,0xbf5a28c5,2
+np.float32,0xbf331bdd,0xbf270209,2
+np.float32,0x7f51c901,0x42b26f0d,2
+np.float32,0x3f67c33b,0x3f5014d8,2
+np.float32,0xbbc9d980,0xbbc9d92c,2
+np.float32,0xbc407540,0xbc40741e,2
+np.float32,0x7eed9a3c,0x42b14be9,2
+np.float32,0x1be0fe,0x1be0fe,2
+np.float32,0xbf6b4913,0xbf52af1f,2
+np.float32,0xbda8eba8,0xbda8bac6,2
+np.float32,0x8004bcea,0x8004bcea,2
+np.float32,0xff6f6afe,0xc2b2b2b3,2
+np.float32,0xbf205810,0xbf175e50,2
+np.float32,0x80651944,0x80651944,2
+np.float32,0xbec73016,0xbec27a3f,2
+np.float32,0x5701b9,0x5701b9,2
+np.float32,0xbf1062ce,0xbf09a7df,2
+np.float32,0x3e0306ae,0x3e02abd1,2
+np.float32,0x7bfc62,0x7bfc62,2
+np.float32,0xbf48dd3c,0xbf387a6b,2
+np.float32,0x8009573e,0x8009573e,2
+np.float32,0x660a2c,0x660a2c,2
+np.float32,0xff2280da,0xc2b1ec4b,2
+np.float32,0xbf7034fe,0xbf564a54,2
+np.float32,0xbeeb448e,0xbee3b045,2
+np.float32,0xff4e949c,0xc2b2672b,2
+np.float32,0xbf3c4486,0xbf2e7309,2
+np.float32,0x7eb086d8,0x42b0b3c8,2
+np.float32,0x7eac8aca,0x42b0a817,2
+np.float32,0xfd3d2d60,0xc2acae8b,2
+np.float32,0xbf363226,0xbf2987bd,2
+np.float32,0x7f02e524,0x42b17d8c,2
+np.float32,0x8049a148,0x8049a148,2
+np.float32,0x147202,0x147202,2
+np.float32,0x8031d3f6,0x8031d3f6,2
+np.float32,0xfe78bf68,0xc2b0007d,2
+np.float32,0x7ebd16d0,0x42b0d6fb,2
+np.float32,0xbdaed2e8,0xbdae9cbb,2
+np.float32,0x802833ae,0x802833ae,2
+np.float32,0x7f62adf6,0x42b296b5,2
+np.float32,0xff2841c0,0xc2b1fe1b,2
+np.float32,0xbeb2c47e,0xbeaf523b,2
+np.float32,0x7e42a36e,0x42af82e6,2
+np.float32,0x41ea29,0x41ea29,2
+np.float32,0xbcaaa800,0xbcaaa4d7,2
+np.float64,0x3fed71f27ebae3e5,0x3fea5c6095012ca6,2
+np.float64,0x224dc392449b9,0x224dc392449b9,2
+np.float64,0x3fdf897a7d3f12f5,0x3fde620339360992,2
+np.float64,0xbfe1f99a5123f334,0xbfe124a57cfaf556,2
+np.float64,0xbfd9725c3bb2e4b8,0xbfd8d1e3f75110c7,2
+np.float64,0x3fe38977546712ee,0x3fe27d9d37f4b91f,2
+np.float64,0xbfc36c29e526d854,0xbfc3594743ee45c4,2
+np.float64,0xbfe5cbec332b97d8,0xbfe4638802316849,2
+np.float64,0x2ff35efe5fe6d,0x2ff35efe5fe6d,2
+np.float64,0x7fd3f828e227f051,0x40862a7d4a40b1e0,2
+np.float64,0xffd06fc11620df82,0xc08628ee8f1bf6c8,2
+np.float64,0x3fe5321bf4aa6438,0x3fe3e3d9fa453199,2
+np.float64,0xffd07a323ca0f464,0xc08628f3a2930f8c,2
+np.float64,0x3fdf7abe7abef57c,0x3fde54cb193d49cb,2
+np.float64,0x40941f1881285,0x40941f1881285,2
+np.float64,0xffef18defc7e31bd,0xc0863393f2c9f061,2
+np.float64,0xbfe379f871e6f3f1,0xbfe270620cb68347,2
+np.float64,0xffec829848f90530,0xc08632e210edaa2b,2
+np.float64,0x80070c00574e1801,0x80070c00574e1801,2
+np.float64,0xffce7654b23ceca8,0xc086285291e89975,2
+np.float64,0x7fc9932daa33265a,0x408626ec6cc2b807,2
+np.float64,0x355ee98c6abde,0x355ee98c6abde,2
+np.float64,0x3fac54962c38a920,0x3fac50e40b6c19f2,2
+np.float64,0x800857984af0af31,0x800857984af0af31,2
+np.float64,0x7fea6a3d55f4d47a,0x40863245bf39f179,2
+np.float64,0x3fdb8fab33371f56,0x3fdac5ffc9e1c347,2
+np.float64,0x800a887a7bf510f5,0x800a887a7bf510f5,2
+np.float64,0xbfbdbda3c63b7b48,0xbfbdac9dd5a2d3e8,2
+np.float64,0xbfd4a2457b29448a,0xbfd44acb3b316d6d,2
+np.float64,0x7fd5329a502a6534,0x40862af789b528b5,2
+np.float64,0x3fd96a7bceb2d4f8,0x3fd8ca92104d6cd6,2
+np.float64,0x3fde6a0cd6bcd41a,0x3fdd5f4b85abf749,2
+np.float64,0xbfc7faaff32ff560,0xbfc7d7560b8c4a52,2
+np.float64,0x7fec381b2f787035,0x408632cd0e9c095c,2
+np.float64,0x1fc2eb543f85e,0x1fc2eb543f85e,2
+np.float64,0x7ac6000af58c1,0x7ac6000af58c1,2
+np.float64,0xffe060a87920c150,0xc0862e72c37d5a4e,2
+np.float64,0xbfb7d8c89e2fb190,0xbfb7cffd3c3f8e3a,2
+np.float64,0x3fd91033deb22068,0x3fd87695b067aa1e,2
+np.float64,0x3fec1aff01b835fe,0x3fe95d5cbd729af7,2
+np.float64,0x7fb97f69ec32fed3,0x4086215aaae5c697,2
+np.float64,0x7feaf1e4e5f5e3c9,0x4086326e6ca6a2bb,2
+np.float64,0x800537e44d0a6fc9,0x800537e44d0a6fc9,2
+np.float64,0x800b2a0d0d36541a,0x800b2a0d0d36541a,2
+np.float64,0x3fe2193846e43270,0x3fe140308550138e,2
+np.float64,0x5e2a0a32bc542,0x5e2a0a32bc542,2
+np.float64,0xffe5888b09eb1116,0xc08630a348783aa3,2
+np.float64,0xbfceb9b5033d736c,0xbfce701049c10435,2
+np.float64,0x7fe5d68589abad0a,0x408630c00ce63f23,2
+np.float64,0x8009b5457ff36a8b,0x8009b5457ff36a8b,2
+np.float64,0xbfb5518c2e2aa318,0xbfb54b42638ca718,2
+np.float64,0x3f9c58469838b080,0x3f9c575974fbcd7b,2
+np.float64,0x3fe8db4b4731b697,0x3fe6dc9231587966,2
+np.float64,0x8007d0f77f4fa1f0,0x8007d0f77f4fa1f0,2
+np.float64,0x7fe79eef542f3dde,0x40863160c673c67f,2
+np.float64,0xffbdc0b6163b8170,0xc0862296be4bf032,2
+np.float64,0x3fbb8d3312371a66,0x3fbb7fa76fb4cf8d,2
+np.float64,0xffd8a0eedbb141de,0xc0862c2ac6e512f0,2
+np.float64,0x7fee99d8d87d33b1,0x4086337301c4c8df,2
+np.float64,0xffe7479b552e8f36,0xc0863142fba0f0ec,2
+np.float64,0xffedf8ef4abbf1de,0xc08633488068fe69,2
+np.float64,0x895c4d9f12b8a,0x895c4d9f12b8a,2
+np.float64,0x29b4caf05369a,0x29b4caf05369a,2
+np.float64,0xbfefb90d657f721b,0xbfec01efa2425b35,2
+np.float64,0xde07c3bdbc0f9,0xde07c3bdbc0f9,2
+np.float64,0x7feae9fd02f5d3f9,0x4086326c1368ed5a,2
+np.float64,0x3feab792da756f26,0x3fe84f6e15338ed7,2
+np.float64,0xbfeff8ed72fff1db,0xbfec2f35da06daaf,2
+np.float64,0x8004b2c132896583,0x8004b2c132896583,2
+np.float64,0xbf9fcb00103f9600,0xbf9fc9b1751c569e,2
+np.float64,0x4182b72e83058,0x4182b72e83058,2
+np.float64,0x90820d812105,0x90820d812105,2
+np.float64,0xbfdec9a0ba3d9342,0xbfddb585df607ce1,2
+np.float64,0x7fdc0a69a03814d2,0x40862d347f201b63,2
+np.float64,0xbfef0708937e0e11,0xbfeb82d27f8ea97f,2
+np.float64,0xffda57e4ddb4afca,0xc0862cb49e2e0c4c,2
+np.float64,0xbfa30b9af4261730,0xbfa30a7b4a633060,2
+np.float64,0x7feb57fcc4b6aff9,0x4086328c83957a0b,2
+np.float64,0x7fe6759153eceb22,0x408630f980433963,2
+np.float64,0x7fdd3278c8ba64f1,0x40862d87445243e9,2
+np.float64,0xd3b8e6b9a771d,0xd3b8e6b9a771d,2
+np.float64,0x6267dc88c4cfc,0x6267dc88c4cfc,2
+np.float64,0x7fedd3cf00bba79d,0x4086333e91712ff5,2
+np.float64,0xffbe512ce03ca258,0xc08622bd39314cea,2
+np.float64,0xbfe71742ca6e2e86,0xbfe572ccbf2d010d,2
+np.float64,0x8002fb048c65f60a,0x8002fb048c65f60a,2
+np.float64,0x800d9d9ddf7b3b3c,0x800d9d9ddf7b3b3c,2
+np.float64,0xbfeaf6230df5ec46,0xbfe87f5d751ec3d5,2
+np.float64,0xbfe69973a42d32e8,0xbfe50c680f7002fe,2
+np.float64,0x3fe309cf87e613a0,0x3fe21048714ce1ac,2
+np.float64,0x800435d17a286ba4,0x800435d17a286ba4,2
+np.float64,0x7fefffffffffffff,0x408633ce8fb9f87e,2
+np.float64,0x3fe36ade1766d5bc,0x3fe26379fb285dde,2
+np.float64,0x3f98d8d94831b1c0,0x3f98d839885dc527,2
+np.float64,0xbfd08f7ae5211ef6,0xbfd0618ab5293e1e,2
+np.float64,0xbfcf630bd53ec618,0xbfcf14a0cd20704d,2
+np.float64,0xbfe58f0ca6eb1e1a,0xbfe4312225df8e28,2
+np.float64,0xffef4f6406be9ec7,0xc08633a1ed1d27e5,2
+np.float64,0x7fe10120b3e20240,0x40862ebfaf94e6e8,2
+np.float64,0xffe96c52fbb2d8a5,0xc08631f75d9a59a0,2
+np.float64,0xbfe448a333e89146,0xbfe31fee44c3ec43,2
+np.float64,0x80045ff4e788bfeb,0x80045ff4e788bfeb,2
+np.float64,0x7fefaa2f823f545e,0x408633b8fea29524,2
+np.float64,0xffea6b8bf234d717,0xc0863246248e5960,2
+np.float64,0xbfdb085d80b610bc,0xbfda498b15b43eec,2
+np.float64,0xbfd5e12da3abc25c,0xbfd57970e2b8aecc,2
+np.float64,0x3fcc84928a390925,0x3fcc497c417a89f3,2
+np.float64,0xbfdcb713bf396e28,0xbfdbd46c5e731fd9,2
+np.float64,0xffdf50c0453ea180,0xc0862e16b5562f25,2
+np.float64,0x800342c2f7268587,0x800342c2f7268587,2
+np.float64,0x7feb8b6d743716da,0x4086329b8248de2c,2
+np.float64,0x800a9b18b4953632,0x800a9b18b4953632,2
+np.float64,0xffedaf0d12fb5e19,0xc0863334af82de1a,2
+np.float64,0x800aebda4ab5d7b5,0x800aebda4ab5d7b5,2
+np.float64,0xbfa9f5848433eb10,0xbfa9f2ac7ac065d4,2
+np.float64,0x3fea375928f46eb2,0x3fe7ec9f10eeac7d,2
+np.float64,0x3fd6c213fead8428,0x3fd64dcc1eff5f1b,2
+np.float64,0xbfa0476f44208ee0,0xbfa046bb986007ac,2
+np.float64,0x6c8e18aed91c4,0x6c8e18aed91c4,2
+np.float64,0x8000000000000001,0x8000000000000001,2
+np.float64,0x7fea86b5ba350d6a,0x4086324e59f13027,2
+np.float64,0x2316c3b0462d9,0x2316c3b0462d9,2
+np.float64,0x3fec4e3281389c65,0x3fe983c5c9d65940,2
+np.float64,0x3fbb87c47f772,0x3fbb87c47f772,2
+np.float64,0x8004af00fdc95e03,0x8004af00fdc95e03,2
+np.float64,0xbfd316db9ba62db8,0xbfd2d12765b9d155,2
+np.float64,0x3fec1a7a99f834f6,0x3fe95cf941889b3d,2
+np.float64,0x3feff7e1477fefc3,0x3fec2e782392d4b9,2
+np.float64,0xbfc683ea042d07d4,0xbfc66698cfa5026e,2
+np.float64,0x3fdbc8aaa9b79154,0x3fdafa50e6fc3fff,2
+np.float64,0xfb3b630ff676d,0xfb3b630ff676d,2
+np.float64,0x7fe715ef8eae2bde,0x40863131d794b41f,2
+np.float64,0x7fefa06c11bf40d7,0x408633b686c7996a,2
+np.float64,0x80002a40f5205483,0x80002a40f5205483,2
+np.float64,0x7fe95f3c74b2be78,0x408631f33e37bf76,2
+np.float64,0x3fb2977b32252ef0,0x3fb2934eaf5a4be8,2
+np.float64,0x3fc0f3dbc821e7b8,0x3fc0e745288c84c3,2
+np.float64,0x3fda98da56b531b5,0x3fd9e2b19447dacc,2
+np.float64,0x3f95b9d5202b73aa,0x3f95b96a53282949,2
+np.float64,0x3fdc1ace7738359d,0x3fdb4597d31df7ff,2
+np.float64,0xffeac5bb2e358b76,0xc0863261452ab66c,2
+np.float64,0xbfefb1b78f7f636f,0xbfebfcb9be100ced,2
+np.float64,0xf5c9e191eb93c,0xf5c9e191eb93c,2
+np.float64,0x3fe83a977630752f,0x3fe65d0df90ff6ef,2
+np.float64,0x3fc317515d262ea0,0x3fc3056072b719f0,2
+np.float64,0x7fe2dcfab225b9f4,0x40862f94257c28a2,2
+np.float64,0xca2b115794562,0xca2b115794562,2
+np.float64,0x3fd495301aa92a60,0x3fd43e57108761d5,2
+np.float64,0x800ccc4293199885,0x800ccc4293199885,2
+np.float64,0xc8d3173d91a63,0xc8d3173d91a63,2
+np.float64,0xbf2541bb7e4a8,0xbf2541bb7e4a8,2
+np.float64,0xbfe9a330df334662,0xbfe779816573f5be,2
+np.float64,0xffd5e4c8252bc990,0xc0862b39b3ca5d72,2
+np.float64,0x3fe90f3a53721e75,0x3fe70585ae09531d,2
+np.float64,0xbfe2b5ddc7a56bbc,0xbfe1c7fa91a675ed,2
+np.float64,0xbf981a0360303400,0xbf9819719345073a,2
+np.float64,0x19174b0e322ea,0x19174b0e322ea,2
+np.float64,0xbfd2f71a1725ee34,0xbfd2b2b6f7cd10b1,2
+np.float64,0x80056e83236add07,0x80056e83236add07,2
+np.float64,0x7fe4bc41d9697883,0x40863055f20ce0cb,2
+np.float64,0xffe76e06c46edc0d,0xc086315024b25559,2
+np.float64,0x3fe3c4f0f96789e2,0x3fe2b04b584609bf,2
+np.float64,0x3fe6cfc533ed9f8a,0x3fe538b4d784d5ee,2
+np.float64,0x7fd234a640a4694c,0x408629bfead4f0b2,2
+np.float64,0x3fdbc49c9ab78939,0x3fdaf698a83d08e2,2
+np.float64,0x3fe4c5336ee98a66,0x3fe388c6ddb60e0a,2
+np.float64,0xf4b9497be9729,0xf4b9497be9729,2
+np.float64,0x3fb312be12262580,0x3fb30e3c847c1d16,2
+np.float64,0x3fe9554218f2aa84,0x3fe73c8b311c7a98,2
+np.float64,0xff899816a0333040,0xc08610bfb2cd8559,2
+np.float64,0x8006008ad52c0116,0x8006008ad52c0116,2
+np.float64,0x3fd7d47be4afa8f8,0x3fd74fa71ec17fd0,2
+np.float64,0x8010000000000000,0x8010000000000000,2
+np.float64,0xdf2a9943be553,0xdf2a9943be553,2
+np.float64,0xbfeb86bf1eb70d7e,0xbfe8ed797580ba5c,2
+np.float64,0x800e2c0c28bc5818,0x800e2c0c28bc5818,2
+np.float64,0xbfe2be65d4657ccc,0xbfe1cf578dec2323,2
+np.float64,0xbfedea3a5afbd475,0xbfeab490bf05e585,2
+np.float64,0xbfe04b1583a0962b,0xbfdf523dfd7be25c,2
+np.float64,0x75929bb4eb254,0x75929bb4eb254,2
+np.float64,0x3fd7b4968caf692d,0x3fd731c0938ff97c,2
+np.float64,0x60bd8fd2c17b3,0x60bd8fd2c17b3,2
+np.float64,0xbfdaf15e70b5e2bc,0xbfda345a95ce18fe,2
+np.float64,0x7fdd7c35c2baf86b,0x40862d9b5f40c6b2,2
+np.float64,0x7feeb4d2ab7d69a4,0x4086337a0c0dffaf,2
+np.float64,0xffe65b5a1decb6b4,0xc08630f024420efb,2
+np.float64,0x7feb272b30764e55,0x4086327e2e553aa2,2
+np.float64,0x3fd27513e8a4ea28,0x3fd235ea49670f6a,2
+np.float64,0x3fe6541a6aeca834,0x3fe4d3a5b69fd1b6,2
+np.float64,0xbfe0c6ca0f618d94,0xbfe017058259efdb,2
+np.float64,0x7fc1bf07b7237e0e,0x4086240000fa5a52,2
+np.float64,0x7fe96af9c0f2d5f3,0x408631f6f0f4faa2,2
+np.float64,0x3fe0728be7a0e518,0x3fdf9881a5869de9,2
+np.float64,0xffe8ea4441b1d488,0xc08631ce0685ae7e,2
+np.float64,0xffd0b973f02172e8,0xc08629121e7fdf85,2
+np.float64,0xffe37b907a26f720,0xc0862fd6529401a0,2
+np.float64,0x3fe0ee826461dd05,0x3fe03a2a424a1b40,2
+np.float64,0xbfe8073c92300e79,0xbfe6340cbd179ac1,2
+np.float64,0x800768383f8ed071,0x800768383f8ed071,2
+np.float64,0x8002e467c7c5c8d0,0x8002e467c7c5c8d0,2
+np.float64,0xbfd8d53ea5b1aa7e,0xbfd83fa7243289d7,2
+np.float64,0xffebefce2bb7df9c,0xc08632b874f4f8dc,2
+np.float64,0xffe3be9eb9277d3d,0xc0862ff1ac70ad0b,2
+np.float64,0xffe2f8a82e65f150,0xc0862f9fd9e77d86,2
+np.float64,0xbfa01d151c203a30,0xbfa01c66dc13a70a,2
+np.float64,0x800877062d30ee0d,0x800877062d30ee0d,2
+np.float64,0xaade16a755bc3,0xaade16a755bc3,2
+np.float64,0xbfeb1abc70363579,0xbfe89b52c3b003aa,2
+np.float64,0x80097d0b2ad2fa17,0x80097d0b2ad2fa17,2
+np.float64,0x8001499907429333,0x8001499907429333,2
+np.float64,0x3fe8db2aaf71b656,0x3fe6dc7873f1b235,2
+np.float64,0x5cfeadc4b9fd6,0x5cfeadc4b9fd6,2
+np.float64,0xff3f77d1fe7ef,0xff3f77d1fe7ef,2
+np.float64,0xffeecd56f9bd9aad,0xc08633806cb1163d,2
+np.float64,0xbf96f3ca582de7a0,0xbf96f34c6b8e1c85,2
+np.float64,0x7ed6b44afdad7,0x7ed6b44afdad7,2
+np.float64,0x80071808da4e3012,0x80071808da4e3012,2
+np.float64,0x3feb8aee2bf715dc,0x3fe8f0a55516615c,2
+np.float64,0x800038f62e2071ed,0x800038f62e2071ed,2
+np.float64,0x3fb13f9af2227f30,0x3fb13c456ced8e08,2
+np.float64,0xffd584d1812b09a4,0xc0862b165558ec0c,2
+np.float64,0x800b20c30fb64186,0x800b20c30fb64186,2
+np.float64,0x80024f9646e49f2d,0x80024f9646e49f2d,2
+np.float64,0xffefffffffffffff,0xc08633ce8fb9f87e,2
+np.float64,0x3fdddbcb5bbbb797,0x3fdcde981111f650,2
+np.float64,0xffed14077f3a280e,0xc086330a795ad634,2
+np.float64,0x800fec2da7ffd85b,0x800fec2da7ffd85b,2
+np.float64,0x3fe8205ffc7040c0,0x3fe6482318d217f9,2
+np.float64,0x3013e5226027d,0x3013e5226027d,2
+np.float64,0xffe4e5aad469cb55,0xc0863065dc2fb4e3,2
+np.float64,0x5cb0f7b2b9620,0x5cb0f7b2b9620,2
+np.float64,0xbfeb4537d2768a70,0xbfe8bbb2c1d3bff9,2
+np.float64,0xbfd859e297b0b3c6,0xbfd7cc807948bf9d,2
+np.float64,0x71f00b8ce3e02,0x71f00b8ce3e02,2
+np.float64,0xf5c1b875eb837,0xf5c1b875eb837,2
+np.float64,0xa0f35c8141e8,0xa0f35c8141e8,2
+np.float64,0xffe24860b42490c1,0xc0862f54222f616e,2
+np.float64,0xffcd9ae8583b35d0,0xc08628181e643a42,2
+np.float64,0x7fe9b710c7736e21,0x4086320ec033490f,2
+np.float64,0x3fd2b9ca1d257394,0x3fd277e631f0c0b3,2
+np.float64,0x23559bfc46ab4,0x23559bfc46ab4,2
+np.float64,0x8002adf75e455bef,0x8002adf75e455bef,2
+np.float64,0xbfefa4d75cbf49af,0xbfebf392e51d6a1a,2
+np.float64,0xffcfef263e3fde4c,0xc08628b336adb611,2
+np.float64,0x80061acaa8ec3596,0x80061acaa8ec3596,2
+np.float64,0x7fc1b33be0236677,0x408623faaddcc17e,2
+np.float64,0x7fe3a84083675080,0x40862fe8972e41e1,2
+np.float64,0xbfe756c1276ead82,0xbfe5a6318b061e1b,2
+np.float64,0xbfae4b71b43c96e0,0xbfae46ed0b6203a4,2
+np.float64,0x800421c6d0a8438e,0x800421c6d0a8438e,2
+np.float64,0x8009ad56fe335aae,0x8009ad56fe335aae,2
+np.float64,0xbfe71afc976e35f9,0xbfe575d21f3d7193,2
+np.float64,0x7fec0bbe4c38177c,0x408632c0710f1d8a,2
+np.float64,0x750e1daeea1c4,0x750e1daeea1c4,2
+np.float64,0x800501d4240a03a9,0x800501d4240a03a9,2
+np.float64,0x800794955cef292b,0x800794955cef292b,2
+np.float64,0x3fdf8a87f5bf1510,0x3fde62f4f00cfa19,2
+np.float64,0xbfebebdbc7f7d7b8,0xbfe939e51ba1340c,2
+np.float64,0xbfe3a16217a742c4,0xbfe292039dd08a71,2
+np.float64,0x3fed6cd04c3ad9a1,0x3fea58995973f74b,2
+np.float64,0xffcad8787335b0f0,0xc086274fbb35dd37,2
+np.float64,0x3fcb178e3d362f1c,0x3fcae4c9f3e6dddc,2
+np.float64,0xbfcadc669435b8cc,0xbfcaaae7cf075420,2
+np.float64,0x7fe0e3906321c720,0x40862eb1bacc5c43,2
+np.float64,0xff8ad5edb035abc0,0xc0861120b6404d0b,2
+np.float64,0x3fe175a21562eb44,0x3fe0b13120a46549,2
+np.float64,0xbfeb4c4a5f769895,0xbfe8c1147f1c9d8f,2
+np.float64,0x7fca22f4e63445e9,0x40862718e9b4094e,2
+np.float64,0x3fe4269d0c684d3a,0x3fe3032aa2015c53,2
+np.float64,0x3fef551c09beaa38,0x3febbabe03f49c83,2
+np.float64,0xffd843df9fb087c0,0xc0862c0c52d5e5d9,2
+np.float64,0x7fc497e2ca292fc5,0x40862530bbd9fcc7,2
+np.float64,0x3fee02919efc0523,0x3feac655588a4acd,2
+np.float64,0x7fed1e52c0fa3ca5,0x4086330d4ddd8a2c,2
+np.float64,0xba04d4ef7409b,0xba04d4ef7409b,2
+np.float64,0x3fee22d0937c45a2,0x3feaddd4ca66b447,2
+np.float64,0xffeb2558cf764ab1,0xc086327da4e84053,2
+np.float64,0xbfe103d987e207b3,0xbfe04d04818ad1ff,2
+np.float64,0x3f9fd7fed03faffe,0x3f9fd6ae9a45be84,2
+np.float64,0x800a53ec4c34a7d9,0x800a53ec4c34a7d9,2
+np.float64,0xbfe2feb17f65fd63,0xbfe206b9d33a78a2,2
+np.float64,0x989bdd613139,0x989bdd613139,2
+np.float64,0xbfdd0ad3fb3a15a8,0xbfdc20c32a530741,2
+np.float64,0xbfc4222163284444,0xbfc40d1c612784b5,2
+np.float64,0xc30cf5c78619f,0xc30cf5c78619f,2
+np.float64,0x3fe913bd6732277b,0x3fe70912f76bad71,2
+np.float64,0x98f175f531e2f,0x98f175f531e2f,2
+np.float64,0x3fed8c1f717b183f,0x3fea6f9fb3af3423,2
+np.float64,0x7fee46b085bc8d60,0x4086335d269eb7e9,2
+np.float64,0x8007480f564e901f,0x8007480f564e901f,2
+np.float64,0xc9b96e179372e,0xc9b96e179372e,2
+np.float64,0x3fe44deac4289bd6,0x3fe32463a74a69e7,2
+np.float64,0x80021d6c5c243ad9,0x80021d6c5c243ad9,2
+np.float64,0xbfebc805a6f7900b,0xbfe91edcf65a1c19,2
+np.float64,0x80044748adc88e92,0x80044748adc88e92,2
+np.float64,0x4007ee44800fe,0x4007ee44800fe,2
+np.float64,0xbfe24307a4648610,0xbfe1648ad5c47b6f,2
+np.float64,0xbfee6d3a93fcda75,0xbfeb13e1a3196e78,2
+np.float64,0x3fe49a287f293451,0x3fe364a11b9f0068,2
+np.float64,0x80052b37ceaa5670,0x80052b37ceaa5670,2
+np.float64,0xbfd42be893a857d2,0xbfd3da05dac7c286,2
+np.float64,0xffb4bbe4ac2977c8,0xc0861fb31bda6956,2
+np.float64,0xbfc732a4142e6548,0xbfc7129a4eafa399,2
+np.float64,0x7fd0696791a0d2ce,0x408628eb7756cb9c,2
+np.float64,0x3fe46c8f8d68d91f,0x3fe33e3df16187c1,2
+np.float64,0x3fe3a28f1ce7451e,0x3fe293043238d08c,2
+np.float64,0xffedc4eb723b89d6,0xc086333a92258c15,2
+np.float64,0x8000d15b4c41a2b7,0x8000d15b4c41a2b7,2
+np.float64,0xffeb73450236e689,0xc08632947b0148ab,2
+np.float64,0xffe68cf4722d19e8,0xc0863101d08d77bd,2
+np.float64,0x800c70eb4698e1d7,0x800c70eb4698e1d7,2
+np.float64,0xffa94387ff529,0xffa94387ff529,2
+np.float64,0x7fe3835d996706ba,0x40862fd985ff8e7d,2
+np.float64,0x3fe55e476feabc8e,0x3fe408a15594ec52,2
+np.float64,0xffc69672222d2ce4,0xc08625ee0c4c0f6a,2
+np.float64,0xbf9d900b883b2020,0xbf9d8efe811d36df,2
+np.float64,0xbfdb9b9755b7372e,0xbfdad0f2aa2cb110,2
+np.float64,0xffeade6073b5bcc0,0xc08632689f17a25d,2
+np.float64,0xffd1d6a6baa3ad4e,0xc086299630a93a7b,2
+np.float64,0x7fd05ba25620b744,0x408628e4be1ef845,2
+np.float64,0xbfc7d422d52fa844,0xbfc7b170a61531bf,2
+np.float64,0x3fd5196797aa32d0,0x3fd4bc0f0e7d8e1d,2
+np.float64,0x617594a4c2eb3,0x617594a4c2eb3,2
+np.float64,0x7fd779bc4caef378,0x40862bc89271b882,2
+np.float64,0xffd2fb262ba5f64c,0xc0862a15561e9524,2
+np.float64,0x72fd661ae5fad,0x72fd661ae5fad,2
+np.float64,0x3fecf441f339e884,0x3fe9ff880d584f64,2
+np.float64,0x7fc3a8968827512c,0x408624d198b05c61,2
+np.float64,0x3fe7a25c56ef44b9,0x3fe5e32509a7c32d,2
+np.float64,0x7fd117d514222fa9,0x4086293ec640d5f2,2
+np.float64,0x3fe37dfe5ee6fbfc,0x3fe273d1bcaa1ef0,2
+np.float64,0xbfed4cd19d7a99a3,0xbfea41064cba4c8b,2
+np.float64,0x8003ff12aaa7fe26,0x8003ff12aaa7fe26,2
+np.float64,0x3fcbc3d1193787a2,0x3fcb8d39e3e88264,2
+np.float64,0xe9ba1a91d3744,0xe9ba1a91d3744,2
+np.float64,0x8002ab71998556e4,0x8002ab71998556e4,2
+np.float64,0x800110057922200c,0x800110057922200c,2
+np.float64,0xbfe3b7af19a76f5e,0xbfe2a502fc0a2882,2
+np.float64,0x7fd9de9d5e33bd3a,0x40862c8f73cccabf,2
+np.float64,0xbfba0f0a86341e18,0xbfba0392f44c2771,2
+np.float64,0x8000000000000000,0x8000000000000000,2
+np.float64,0x7fe5d162e96ba2c5,0x408630be2b15e01b,2
+np.float64,0x800b7f0eac76fe1e,0x800b7f0eac76fe1e,2
+np.float64,0xff98bed150317da0,0xc086160633164f5f,2
+np.float64,0x3fef91fd70ff23fb,0x3febe629709d0ae7,2
+np.float64,0x7fe5bea7f16b7d4f,0x408630b749f445e9,2
+np.float64,0xbfe3dc428467b885,0xbfe2c41ea93fab07,2
+np.float64,0xbfeba1fbfcf743f8,0xbfe9021b52851bb9,2
+np.float64,0x7fd2fb2108a5f641,0x40862a1553f45830,2
+np.float64,0x7feb8199a4370332,0x40863298a7169dad,2
+np.float64,0x800f97ff8d7f2fff,0x800f97ff8d7f2fff,2
+np.float64,0x3fd5e20b6b2bc417,0x3fd57a42bd1c0993,2
+np.float64,0x8006b4072dad680f,0x8006b4072dad680f,2
+np.float64,0x605dccf2c0bba,0x605dccf2c0bba,2
+np.float64,0x3fc705ed142e0bda,0x3fc6e69971d86f73,2
+np.float64,0xffd2ba1aad257436,0xc08629f9bc918f8b,2
+np.float64,0x8002954e23c52a9d,0x8002954e23c52a9d,2
+np.float64,0xbfecc65da7798cbb,0xbfe9dd745be18562,2
+np.float64,0x7fc66110482cc220,0x408625db0db57ef8,2
+np.float64,0x3fcd09446d3a1289,0x3fcccaf2dd0a41ea,2
+np.float64,0x3febe7095437ce13,0x3fe93642d1e73b2a,2
+np.float64,0x8004773c7da8ee7a,0x8004773c7da8ee7a,2
+np.float64,0x8001833241230665,0x8001833241230665,2
+np.float64,0x3fe6a262db6d44c6,0x3fe513b3dab5adce,2
+np.float64,0xe6282cc1cc506,0xe6282cc1cc506,2
+np.float64,0x800b9d8553973b0b,0x800b9d8553973b0b,2
+np.float64,0x3fdfbe0c7b3f7c19,0x3fde912375d867a8,2
+np.float64,0x7fd5ac11ebab5823,0x40862b24dfc6d08e,2
+np.float64,0x800e4b7cb1fc96f9,0x800e4b7cb1fc96f9,2
+np.float64,0x3fe14706da628e0e,0x3fe0883aec2a917a,2
+np.float64,0x7fc963f97532c7f2,0x408626dd9b0cafe1,2
+np.float64,0xbfe9c250b5b384a2,0xbfe791c5eabcb05d,2
+np.float64,0x3fe8d16e6c71a2dd,0x3fe6d4c7a33a0bf4,2
+np.float64,0x3fe474ae4628e95d,0x3fe34515c93f4733,2
+np.float64,0x3fbf3257ee3e64b0,0x3fbf1eb530e126ea,2
+np.float64,0x8005f089b3abe114,0x8005f089b3abe114,2
+np.float64,0x3fece07bccf9c0f8,0x3fe9f0dc228124d5,2
+np.float64,0xbfc52521632a4a44,0xbfc50ccebdf59c2c,2
+np.float64,0x7fdf53beb13ea77c,0x40862e177918195e,2
+np.float64,0x8003d9f6ad07b3ee,0x8003d9f6ad07b3ee,2
+np.float64,0xffeacf96bbb59f2d,0xc086326436b38b1a,2
+np.float64,0xdccaea29b995e,0xdccaea29b995e,2
+np.float64,0x5948d21eb291b,0x5948d21eb291b,2
+np.float64,0x10000000000000,0x10000000000000,2
+np.float64,0x7fef6d2c543eda58,0x408633a98593cdf5,2
+np.float64,0x7feda454f47b48a9,0x40863331cb6dc9f7,2
+np.float64,0x3fdd377cecba6ef8,0x3fdc4968f74a9c83,2
+np.float64,0x800644096d4c8814,0x800644096d4c8814,2
+np.float64,0xbfe33ca15ae67942,0xbfe23be5de832bd8,2
+np.float64,0xffce9582bd3d2b04,0xc086285abdf9bf9d,2
+np.float64,0x3fe6621e86acc43d,0x3fe4df231bfa93e1,2
+np.float64,0xee7d19e9dcfa3,0xee7d19e9dcfa3,2
+np.float64,0x800be5997277cb33,0x800be5997277cb33,2
+np.float64,0x82069041040e,0x82069041040e,2
+np.float64,0x800d6efdc19addfc,0x800d6efdc19addfc,2
+np.float64,0x7fb27770ee24eee1,0x40861ec5ed91b839,2
+np.float64,0x3fd506064caa0c0d,0x3fd4a9a66353fefd,2
+np.float64,0xbfeca9b36bf95367,0xbfe9c81f03ba37b8,2
+np.float64,0xffeab1b7bab5636f,0xc086325b47f61f2b,2
+np.float64,0xffc99f5b2e333eb8,0xc08626f03b08b412,2
+np.float64,0x3fbf1a71bc3e34e3,0x3fbf06fbcaa5de58,2
+np.float64,0x3fe75015736ea02b,0x3fe5a0cd8d763d8d,2
+np.float64,0xffe6a7442fad4e88,0xc086310b20addba4,2
+np.float64,0x3fe5d62ff86bac60,0x3fe46c033195bf28,2
+np.float64,0x7fd0b1f0362163df,0x4086290e857dc1be,2
+np.float64,0xbe0353737c06b,0xbe0353737c06b,2
+np.float64,0x7fec912d8739225a,0x408632e627704635,2
+np.float64,0xded8ba2fbdb18,0xded8ba2fbdb18,2
+np.float64,0x7fec0b53fdf816a7,0x408632c052bc1bd2,2
+np.float64,0x7fe9640d12b2c819,0x408631f4c2ba54d8,2
+np.float64,0x800be714eeb7ce2a,0x800be714eeb7ce2a,2
+np.float64,0xbfcf444a793e8894,0xbfcef6c126b54853,2
+np.float64,0xffeb20cf1bf6419e,0xc086327c4e6ffe80,2
+np.float64,0xc07de22180fd,0xc07de22180fd,2
+np.float64,0xffed129d387a253a,0xc086330a15ad0adb,2
+np.float64,0x3fd9e94fedb3d2a0,0x3fd94049924706a8,2
+np.float64,0x7fe6ba488c2d7490,0x40863111d51e7861,2
+np.float64,0xbfebbdf25db77be5,0xbfe91740ad7ba521,2
+np.float64,0x7fbc6c3c4838d878,0x40862239160cb613,2
+np.float64,0xbfefa82ecebf505e,0xbfebf5f31957dffd,2
+np.float64,0x800bebeb7ad7d7d7,0x800bebeb7ad7d7d7,2
+np.float64,0x7fecccc6f8f9998d,0x408632f6c6da8aac,2
+np.float64,0xcbe4926197ca,0xcbe4926197ca,2
+np.float64,0x2c5d9fd858bb5,0x2c5d9fd858bb5,2
+np.float64,0xbfe9fb021073f604,0xbfe7bddc61f1151a,2
+np.float64,0xbfebb18572f7630b,0xbfe90ddc5002313f,2
+np.float64,0x13bb0d3227763,0x13bb0d3227763,2
+np.float64,0x3feefa5e5cbdf4bd,0x3feb79b9e8ce16bf,2
+np.float64,0x3fc97f086132fe10,0x3fc9549fc8e15ecb,2
+np.float64,0xffe70887c06e110f,0xc086312d30fd31cf,2
+np.float64,0xa00c113540182,0xa00c113540182,2
+np.float64,0x800950984772a131,0x800950984772a131,2
+np.float64,0x1,0x1,2
+np.float64,0x3fd83b4026b07680,0x3fd7afdc659d9a34,2
+np.float64,0xbfe32348fbe64692,0xbfe226292a706a1a,2
+np.float64,0x800b894dcc77129c,0x800b894dcc77129c,2
+np.float64,0xeb2ca419d6595,0xeb2ca419d6595,2
+np.float64,0xbff0000000000000,0xbfec34366179d427,2
+np.float64,0x3feb269e99f64d3d,0x3fe8a4634b927a21,2
+np.float64,0xbfe83149d7706294,0xbfe655a2b245254e,2
+np.float64,0xbfe6eef3ca6ddde8,0xbfe5521310e24d16,2
+np.float64,0x3fea89a4b7b51349,0x3fe82c1fc69edcec,2
+np.float64,0x800f2a8bf17e5518,0x800f2a8bf17e5518,2
+np.float64,0x800f71fac29ee3f6,0x800f71fac29ee3f6,2
+np.float64,0xe7cb31f1cf966,0xe7cb31f1cf966,2
+np.float64,0x3b0f8752761f2,0x3b0f8752761f2,2
+np.float64,0x3fea27dea3744fbd,0x3fe7e0a4705476b2,2
+np.float64,0xbfa97c019c32f800,0xbfa97950c1257b92,2
+np.float64,0xffeff13647ffe26c,0xc08633cadc7105ed,2
+np.float64,0x3feee162353dc2c4,0x3feb67c2da0fbce8,2
+np.float64,0x80088c0807911810,0x80088c0807911810,2
+np.float64,0x3fe936ab1db26d56,0x3fe72489bc69719d,2
+np.float64,0xa2f84bd545f0a,0xa2f84bd545f0a,2
+np.float64,0xbfed445ed27a88be,0xbfea3acac0aaf482,2
+np.float64,0x800faf3e69df5e7d,0x800faf3e69df5e7d,2
+np.float64,0x3fc145a330228b46,0x3fc13853f11b1c90,2
+np.float64,0xbfe25ec5abe4bd8c,0xbfe17c9e9b486f07,2
+np.float64,0x3fe119b160e23363,0x3fe0604b10178966,2
+np.float64,0x7fe0cbf2836197e4,0x40862ea6831e5f4a,2
+np.float64,0x3fe75dd3b4eebba8,0x3fe5abe80fd628fb,2
+np.float64,0x3f7c391000387220,0x3f7c39015d8f3a36,2
+np.float64,0x899d9cad133b4,0x899d9cad133b4,2
+np.float64,0x3fe5f0e34febe1c6,0x3fe4820cefe138fc,2
+np.float64,0x7fe060dfdba0c1bf,0x40862e72de8afcd0,2
+np.float64,0xbfae42f7103c85f0,0xbfae3e7630819c60,2
+np.float64,0x35f1f2c06be5,0x35f1f2c06be5,2
+np.float64,0xffc5194d362a329c,0xc086256266c8b7ad,2
+np.float64,0xbfda034f1b34069e,0xbfd95860a44c43ad,2
+np.float64,0x32bcebca6579e,0x32bcebca6579e,2
+np.float64,0xbfd1751ebca2ea3e,0xbfd13f79f45bf75c,2
+np.float64,0x3fee4fa1e5bc9f44,0x3feafe69e0d6c1c7,2
+np.float64,0x7f9c03cd5038079a,0x4086170459172900,2
+np.float64,0x7fc5fb6d6d2bf6da,0x408625b6651cfc73,2
+np.float64,0x7ff8000000000000,0x7ff8000000000000,2
+np.float64,0xffd1a8162ca3502c,0xc0862981333931ad,2
+np.float64,0x7fc415c198282b82,0x408624fd8c155d1b,2
+np.float64,0xffda37fbe7b46ff8,0xc0862caae7865c43,2
+np.float64,0xbfef4312257e8624,0xbfebadd89f3ee31c,2
+np.float64,0xbfec45e1fd788bc4,0xbfe97d8b14db6274,2
+np.float64,0xbfe6fdcfd26dfba0,0xbfe55e25b770d00a,2
+np.float64,0x7feb66d424f6cda7,0x40863290d9ff7ea2,2
+np.float64,0x8b08a29916115,0x8b08a29916115,2
+np.float64,0xffe12ca25c625944,0xc0862ed40d769f72,2
+np.float64,0x7ff4000000000000,0x7ffc000000000000,2
+np.float64,0x804925e100925,0x804925e100925,2
+np.float64,0xcebf3e019d9,0xcebf3e019d9,2
+np.float64,0xbfd5d75d4aabaeba,0xbfd57027671dedf7,2
+np.float64,0x800b829ecd37053e,0x800b829ecd37053e,2
+np.float64,0x800b1205daf6240c,0x800b1205daf6240c,2
+np.float64,0x3fdf7e9889befd31,0x3fde583fdff406c3,2
+np.float64,0x7ff0000000000000,0x7ff0000000000000,2
+np.float64,0x3fdc09760d3812ec,0x3fdb35b55c8090c6,2
+np.float64,0x800c4d99e4f89b34,0x800c4d99e4f89b34,2
+np.float64,0xffbaa6772e354cf0,0xc08621b535badb2f,2
+np.float64,0xbfc91188fd322310,0xbfc8e933b5d25ea7,2
+np.float64,0xffc1b947f4237290,0xc08623fd69164251,2
+np.float64,0x3fc6ab3b252d5678,0x3fc68d50bbac106d,2
+np.float64,0xffac8eb968391d70,0xc0861cb734833355,2
+np.float64,0xffe29a35c365346b,0xc0862f77a1aed6d8,2
+np.float64,0x3fde14b9543c2973,0x3fdd122697779015,2
+np.float64,0xbf10f5400021e000,0xbf10f53fffef1383,2
+np.float64,0xffe0831aa3e10635,0xc0862e838553d0ca,2
+np.float64,0x3fccbadbcf3975b8,0x3fcc7e768d0154ec,2
+np.float64,0x3fe092ef66e125df,0x3fdfd212a7116c9b,2
+np.float64,0xbfd727f039ae4fe0,0xbfd6adad040b2334,2
+np.float64,0xbfe4223b93a84477,0xbfe2ff7587364db4,2
+np.float64,0x3f4e5c3a003cb874,0x3f4e5c39b75c70f7,2
+np.float64,0x800e76b1a87ced63,0x800e76b1a87ced63,2
+np.float64,0x3fed2b7368fa56e7,0x3fea2863b9131b8c,2
+np.float64,0xffadb76ec43b6ee0,0xc0861d08ae79f20c,2
+np.float64,0x800b6a0cd1f6d41a,0x800b6a0cd1f6d41a,2
+np.float64,0xffee6aa943fcd552,0xc0863366a24250d5,2
+np.float64,0xbfe68cbc4e6d1978,0xbfe502040591aa5b,2
+np.float64,0xff859a38002b3480,0xc0860f64726235cc,2
+np.float64,0x3474d13e68e9b,0x3474d13e68e9b,2
+np.float64,0xffc11d49f6223a94,0xc08623b5c2df9712,2
+np.float64,0x800d82d019bb05a0,0x800d82d019bb05a0,2
+np.float64,0xbfe2af0192255e03,0xbfe1c20e38106388,2
+np.float64,0x3fe97d13c032fa28,0x3fe75bba11a65f86,2
+np.float64,0x7fcd457e133a8afb,0x40862800e80f5863,2
+np.float64,0x9d7254cf3ae4b,0x9d7254cf3ae4b,2
+np.float64,0x8003047675a608ee,0x8003047675a608ee,2
+np.float64,0x3fead6cd7d75ad9a,0x3fe8676138e5ff93,2
+np.float64,0x3fea6ee3b0f4ddc7,0x3fe817838a2bcbe3,2
+np.float64,0x3feed0edea7da1dc,0x3feb5bea3cb12fe2,2
+np.float64,0x88003fe510008,0x88003fe510008,2
+np.float64,0x3fe64cadc56c995c,0x3fe4cd8ead87fc79,2
+np.float64,0xaae30c5955c62,0xaae30c5955c62,2
+np.float64,0x7fc8c97cae3192f8,0x408626ac579f4fc5,2
+np.float64,0xbfc2bc0e8b25781c,0xbfc2ab188fdab7dc,2
+np.float64,0xc8f8e5e791f1d,0xc8f8e5e791f1d,2
+np.float64,0x3fecfaa5d6f9f54c,0x3fea0444dabe5a15,2
+np.float64,0xbfeb93740ff726e8,0xbfe8f71a9ab13baf,2
+np.float64,0xffd951236c32a246,0xc0862c633a4661eb,2
+np.float64,0x3fddbc5fcd3b78c0,0x3fdcc21c1a0a9246,2
+np.float64,0xbfd242443da48488,0xbfd20512d91f7924,2
+np.float64,0x2a3689b2546d2,0x2a3689b2546d2,2
+np.float64,0xffe24c67382498ce,0xc0862f55e4ea6283,2
+np.float64,0x800cbfce22197f9c,0x800cbfce22197f9c,2
+np.float64,0x8002269428044d29,0x8002269428044d29,2
+np.float64,0x7fd44babbd289756,0x40862a9e79b51c3b,2
+np.float64,0x3feea056a27d40ad,0x3feb38dcddb682f0,2
+np.float64,0xffeca8174b39502e,0xc08632ec8f88a5b2,2
+np.float64,0x7fbe0853a03c10a6,0x408622a9e8d53a9e,2
+np.float64,0xbfa9704b2432e090,0xbfa96d9dfc8c0cc2,2
+np.float64,0x800bda28fab7b452,0x800bda28fab7b452,2
+np.float64,0xbfb0ffa2f621ff48,0xbfb0fc71f405e82a,2
+np.float64,0xbfe66c04216cd808,0xbfe4e73ea3b58cf6,2
+np.float64,0x3fe336ea5d266dd5,0x3fe236ffcf078c62,2
+np.float64,0xbfe7729ae6aee536,0xbfe5bcad4b8ac62d,2
+np.float64,0x558cfc96ab1a0,0x558cfc96ab1a0,2
+np.float64,0xbfe7d792aaefaf26,0xbfe60de1b8f0279d,2
+np.float64,0xffd19ef6bda33dee,0xc086297d0ffee3c7,2
+np.float64,0x666b3ab4ccd68,0x666b3ab4ccd68,2
+np.float64,0xffa3d89e3c27b140,0xc08619cdeb2c1e49,2
+np.float64,0xbfb1728f7f62f,0xbfb1728f7f62f,2
+np.float64,0x3fc76319f32ec634,0x3fc74247bd005e20,2
+np.float64,0xbfbf1caee23e3960,0xbfbf0934c13d70e2,2
+np.float64,0x7fe79626f32f2c4d,0x4086315dcc68a5cb,2
+np.float64,0xffee78c4603cf188,0xc086336a572c05c2,2
+np.float64,0x3fce546eda3ca8de,0x3fce0d8d737fd31d,2
+np.float64,0xa223644d4446d,0xa223644d4446d,2
+np.float64,0x3fecea878b79d510,0x3fe9f850d50973f6,2
+np.float64,0x3fc20e0ea1241c1d,0x3fc1fedda87c5e75,2
+np.float64,0xffd1c5a99ca38b54,0xc086298e8e94cd47,2
+np.float64,0x7feb2c299d765852,0x4086327fa6db2808,2
+np.float64,0xcaf9d09595f3a,0xcaf9d09595f3a,2
+np.float64,0xbfe293bf21e5277e,0xbfe1aa7f6ac274ef,2
+np.float64,0xbfbaa3c8ce354790,0xbfba97891df19c01,2
+np.float64,0x3faf5784543eaf09,0x3faf5283acc7d71d,2
+np.float64,0x7fc014f8f62029f1,0x40862336531c662d,2
+np.float64,0xbfe0d9ac2d61b358,0xbfe027bce36699ca,2
+np.float64,0x8003e112ff27c227,0x8003e112ff27c227,2
+np.float64,0xffec0d4151381a82,0xc08632c0df718dd0,2
+np.float64,0x7fa2156fb0242ade,0x4086190f7587d708,2
+np.float64,0xd698358dad307,0xd698358dad307,2
+np.float64,0xbfed8d1b0efb1a36,0xbfea70588ef9ba18,2
+np.float64,0xbfd2cae6a92595ce,0xbfd28851e2185dee,2
+np.float64,0xffe7a36764ef46ce,0xc086316249c9287a,2
+np.float64,0xbfdb8ad8e5b715b2,0xbfdac19213c14315,2
+np.float64,0x3b5dba6076bc,0x3b5dba6076bc,2
+np.float64,0x800e6e8347bcdd07,0x800e6e8347bcdd07,2
+np.float64,0x800bea9f3fb7d53f,0x800bea9f3fb7d53f,2
+np.float64,0x7fb6d0e5fc2da1cb,0x4086207714c4ab85,2
+np.float64,0x0,0x0,2
+np.float64,0xbfe2aa1e1465543c,0xbfe1bdd550ef2966,2
+np.float64,0x7fd3f6a47fa7ed48,0x40862a7caea33055,2
+np.float64,0x800094e292c129c6,0x800094e292c129c6,2
+np.float64,0x800e1500ecbc2a02,0x800e1500ecbc2a02,2
+np.float64,0xbfd8ff6f97b1fee0,0xbfd866f84346ecdc,2
+np.float64,0x681457d0d028c,0x681457d0d028c,2
+np.float64,0x3feed0b5987da16b,0x3feb5bc1ab424984,2
+np.float64,0x3fdbcb34cdb79668,0x3fdafca540f32c06,2
+np.float64,0xbfdc9eacdcb93d5a,0xbfdbbe274aa8aeb0,2
+np.float64,0xffe6e35d526dc6ba,0xc08631203df38ed2,2
+np.float64,0x3fcac1cc65358398,0x3fca90de41889613,2
+np.float64,0xbfebf07a55b7e0f5,0xbfe93d6007db0c67,2
+np.float64,0xbfd7a7b1e7af4f64,0xbfd725a9081c22cb,2
+np.float64,0x800232bd7de4657c,0x800232bd7de4657c,2
+np.float64,0x7fb1dae43c23b5c7,0x40861e80f5c0a64e,2
+np.float64,0x8013ded70027c,0x8013ded70027c,2
+np.float64,0x7fc4373a59286e74,0x4086250ad60575d0,2
+np.float64,0xbfe9980fd6733020,0xbfe770d1352d0ed3,2
+np.float64,0x8008a66b8dd14cd7,0x8008a66b8dd14cd7,2
+np.float64,0xbfaebc67f83d78d0,0xbfaeb7b015848478,2
+np.float64,0xffd0c52762218a4e,0xc0862917b564afc6,2
+np.float64,0xbfd503860aaa070c,0xbfd4a74618441561,2
+np.float64,0x5bdacabcb7b5a,0x5bdacabcb7b5a,2
+np.float64,0xf3623cffe6c48,0xf3623cffe6c48,2
+np.float64,0x7fe16c6c7ea2d8d8,0x40862ef18d90201f,2
+np.float64,0x3ff0000000000000,0x3fec34366179d427,2
+np.float64,0x7fe19cbc84233978,0x40862f079dcbc169,2
+np.float64,0x3fcfd3d6933fa7ad,0x3fcf822187907f6b,2
+np.float64,0x8007d65d672facbc,0x8007d65d672facbc,2
+np.float64,0xffca6115aa34c22c,0xc086272bd7728750,2
+np.float64,0xbfe77ab1556ef562,0xbfe5c332fb55b66e,2
+np.float64,0x8001ed797c23daf4,0x8001ed797c23daf4,2
+np.float64,0x7fdd3d16cb3a7a2d,0x40862d8a2c869281,2
+np.float64,0x75f36beaebe6e,0x75f36beaebe6e,2
+np.float64,0xffda3c2798b47850,0xc0862cac2d3435df,2
+np.float64,0xbfa37cc3c426f980,0xbfa37b8f9d3ec4b7,2
+np.float64,0x80030ea8bd061d52,0x80030ea8bd061d52,2
+np.float64,0xffe41f7617683eec,0xc08630188a3e135e,2
+np.float64,0x800e40590dfc80b2,0x800e40590dfc80b2,2
+np.float64,0x3fea950d80f52a1c,0x3fe834e74481e66f,2
+np.float64,0xffec95e39a792bc6,0xc08632e779150084,2
+np.float64,0xbfd54310ecaa8622,0xbfd4e39c4d767002,2
+np.float64,0xffd40c9971a81932,0xc0862a85764eb2f4,2
+np.float64,0xb0a2230761445,0xb0a2230761445,2
+np.float64,0x80092973661252e7,0x80092973661252e7,2
+np.float64,0x7fb13b030a227605,0x40861e380aeb5549,2
+np.float64,0x3fbd5d8db23abb1b,0x3fbd4d2a0b94af36,2
+np.float64,0xbfd6cb8567ad970a,0xbfd656b19ab8fa61,2
+np.float64,0xbfe7c0fd346f81fa,0xbfe5fbc28807c794,2
+np.float64,0xffd586579eab0cb0,0xc0862b16e65c0754,2
+np.float64,0x8000e52da461ca5c,0x8000e52da461ca5c,2
+np.float64,0x3fc69d17112d3a2e,0x3fc67f63fe1fea1c,2
+np.float64,0x3fd36ba892a6d750,0x3fd3225be1fa87af,2
+np.float64,0x7fe2850598e50a0a,0x40862f6e7fcd6c1a,2
+np.float64,0x80074a4dacce949c,0x80074a4dacce949c,2
+np.float64,0x3fe25eea4d64bdd5,0x3fe17cbe5fefbd4e,2
+np.float64,0xbfe250c08be4a181,0xbfe17074c520e5de,2
+np.float64,0x8000f5665481eacd,0x8000f5665481eacd,2
+np.float64,0x7fdb3172f83662e5,0x40862cf5a46764f1,2
+np.float64,0x7fd8ed82d631db05,0x40862c4380658afa,2
+np.float64,0xffec5163feb8a2c7,0xc08632d4366aab06,2
+np.float64,0x800ff14ac6ffe296,0x800ff14ac6ffe296,2
+np.float64,0xbfc7cc7aea2f98f4,0xbfc7a9e9cb38f023,2
+np.float64,0xbfd50cdfc32a19c0,0xbfd4b0282b452fb2,2
+np.float64,0xbfec256d75b84adb,0xbfe965328c1860b2,2
+np.float64,0xffe860c4cdb0c189,0xc08631a164b7059a,2
+np.float64,0xbfe23de164247bc3,0xbfe16011bffa4651,2
+np.float64,0xcc96b39d992d7,0xcc96b39d992d7,2
+np.float64,0xbfec43acf938875a,0xbfe97be3a13b50c3,2
+np.float64,0xc4f587bb89eb1,0xc4f587bb89eb1,2
+np.float64,0xbfcd971d9a3b2e3c,0xbfcd5537ad15dab4,2
+np.float64,0xffcaf00d8035e01c,0xc0862756bf2cdf8f,2
+np.float64,0x8008c26f93f184e0,0x8008c26f93f184e0,2
+np.float64,0xfff0000000000000,0xfff0000000000000,2
+np.float64,0xbfd13552c3a26aa6,0xbfd101e5e252eb7b,2
+np.float64,0x7fe497235e292e46,0x4086304792fb423a,2
+np.float64,0x7fd6dc0192adb802,0x40862b921a5e935d,2
+np.float64,0xf16d49a1e2da9,0xf16d49a1e2da9,2
+np.float64,0xffef6b1b71bed636,0xc08633a8feed0178,2
+np.float64,0x7fe15ec62f62bd8b,0x40862eeb46b193dc,2
+np.float64,0x3fef4369ec7e86d4,0x3febae1768be52cc,2
+np.float64,0x4f84e8e89f09e,0x4f84e8e89f09e,2
+np.float64,0xbfe19e71ade33ce4,0xbfe0d4fad05e0ebc,2
+np.float64,0xbfe7e1df1defc3be,0xbfe616233e15b3d0,2
+np.float64,0x7fe9349afdb26935,0x408631e5c1c5c6cd,2
+np.float64,0xff90c35ac82186c0,0xc08612e896a06467,2
+np.float64,0xbfe88bf8807117f1,0xbfe69dc786464422,2
+np.float64,0x3feaf9ff6475f3fe,0x3fe8825132410d18,2
+np.float64,0x9ff487a33fe91,0x9ff487a33fe91,2
+np.float64,0x7fedb30159bb6602,0x40863335c0419322,2
+np.float64,0x800bddf6ed77bbee,0x800bddf6ed77bbee,2
+np.float64,0x3fd919df133233be,0x3fd87f963b9584ce,2
+np.float64,0x7fd64da3b52c9b46,0x40862b5fa9dd3b6d,2
+np.float64,0xbfce288db43c511c,0xbfcde2d953407ae8,2
+np.float64,0x3fe88bc72771178e,0x3fe69da05e9e9b4e,2
+np.float64,0x800feafe259fd5fc,0x800feafe259fd5fc,2
+np.float64,0x3febbbff4a7777ff,0x3fe915c78f6a280f,2
+np.float64,0xbfefbde4417f7bc9,0xbfec055f4fb2cd21,2
+np.float64,0xf13ca103e2794,0xf13ca103e2794,2
+np.float64,0x3fe6423884ec8471,0x3fe4c4f97eaa876a,2
+np.float64,0x800ca01c8cb94039,0x800ca01c8cb94039,2
+np.float64,0x3fbc5073f638a0e0,0x3fbc41c163ac0001,2
+np.float64,0xbfda0d83cfb41b08,0xbfd961d4cacc82cf,2
+np.float64,0x800f37b8f17e6f72,0x800f37b8f17e6f72,2
+np.float64,0x7fe0b08cd7216119,0x40862e996becb771,2
+np.float64,0xffd4222a40a84454,0xc0862a8e0c984917,2
+np.float64,0x7feb3df98ff67bf2,0x40863284e3a86ee6,2
+np.float64,0x8001d5d291e3aba6,0x8001d5d291e3aba6,2
+np.float64,0xbfd3c21629a7842c,0xbfd3750095a5894a,2
+np.float64,0xbfd069eb48a0d3d6,0xbfd03d2b1c2ae9db,2
+np.float64,0xffeb1be2973637c4,0xc086327ada954662,2
+np.float64,0x3fc659f97e2cb3f3,0x3fc63d497a451f10,2
+np.float64,0xbfeb624bc776c498,0xbfe8d1cf7c0626ca,2
+np.float64,0xffeedf26e23dbe4d,0xc08633850baab425,2
+np.float64,0xffe70da48a6e1b48,0xc086312ef75d5036,2
+np.float64,0x2b4f4830569ea,0x2b4f4830569ea,2
+np.float64,0xffe82e7fcfb05cff,0xc0863190d4771f75,2
+np.float64,0x3fcc2c1fd5385840,0x3fcbf3211ddc5123,2
+np.float64,0x7fe22ced5a6459da,0x40862f481629ee6a,2
+np.float64,0x7fe13d2895e27a50,0x40862edbbc411899,2
+np.float64,0x3fd54c4280aa9884,0x3fd4ec55a946c5d7,2
+np.float64,0xffd75b8e01aeb71c,0xc0862bbe42d76e5e,2
+np.float64,0x7f1d5376fe3ab,0x7f1d5376fe3ab,2
+np.float64,0x3fe6ec6c902dd8d9,0x3fe55004f35192bd,2
+np.float64,0x5634504aac68b,0x5634504aac68b,2
+np.float64,0x3feedb0d83bdb61b,0x3feb633467467ce6,2
+np.float64,0x3fddb1c0dcbb6380,0x3fdcb87a02daf1fa,2
+np.float64,0xbfa832da443065b0,0xbfa8308c70257209,2
+np.float64,0x87a9836b0f531,0x87a9836b0f531,2

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-arctanh.csv

@@ -0,0 +1,1429 @@
+dtype,input,output,ulperrortol
+np.float32,0x3ee82930,0x3efa60fd,2
+np.float32,0x3f0aa640,0x3f1b3e13,2
+np.float32,0x3ec1a21c,0x3ecbbf8d,2
+np.float32,0x3cdb1740,0x3cdb24a1,2
+np.float32,0xbf28b6f3,0xbf4a86ac,2
+np.float32,0xbe490dcc,0xbe4bb2eb,2
+np.float32,0x80000001,0x80000001,2
+np.float32,0xbf44f9dd,0xbf826ce1,2
+np.float32,0xbf1d66c4,0xbf37786b,2
+np.float32,0x3f0ad26a,0x3f1b7c9b,2
+np.float32,0x3f7b6c54,0x4016aab0,2
+np.float32,0xbf715bb8,0xbfe1a0bc,2
+np.float32,0xbee8a562,0xbefafd6a,2
+np.float32,0x3db94d00,0x3db9cf16,2
+np.float32,0x3ee2970c,0x3ef368b3,2
+np.float32,0x3f3f8614,0x3f77fdca,2
+np.float32,0xbf1fb5f0,0xbf3b3789,2
+np.float32,0x3f798dc0,0x400b96bb,2
+np.float32,0x3e975d64,0x3e9c0573,2
+np.float32,0xbe3f1908,0xbe415d1f,2
+np.float32,0x3f2cea38,0x3f52192e,2
+np.float32,0x3e82f1ac,0x3e85eaa1,2
+np.float32,0x3eab6b30,0x3eb24acd,2
+np.float32,0xbe9bb90c,0xbea0cf5f,2
+np.float32,0xbf43e847,0xbf81202f,2
+np.float32,0xbd232fa0,0xbd2345c0,2
+np.float32,0xbbabbc00,0xbbabbc67,2
+np.float32,0xbf0b2975,0xbf1bf808,2
+np.float32,0xbef5ab0a,0xbf05d305,2
+np.float32,0x3f2cad16,0x3f51a8e2,2
+np.float32,0xbef75940,0xbf06eb08,2
+np.float32,0xbf0c1216,0xbf1d4325,2
+np.float32,0x3e7bdc08,0x3e8090c2,2
+np.float32,0x3da14e10,0x3da1a3c5,2
+np.float32,0x3f627412,0x3fb2bf21,2
+np.float32,0xbd6d08c0,0xbd6d4ca0,2
+np.float32,0x3f3e2368,0x3f74df8b,2
+np.float32,0xbe0df104,0xbe0edc77,2
+np.float32,0x3e8a265c,0x3e8da833,2
+np.float32,0xbdccdbb0,0xbdcd8ba8,2
+np.float32,0x3eb080c4,0x3eb80a44,2
+np.float32,0x3e627800,0x3e6645fe,2
+np.float32,0xbd8be0b0,0xbd8c1886,2
+np.float32,0xbf3282ac,0xbf5cae8c,2
+np.float32,0xbe515910,0xbe545707,2
+np.float32,0xbf2e64ac,0xbf54d637,2
+np.float32,0x3e0fc230,0x3e10b6de,2
+np.float32,0x3eb13ca0,0x3eb8df94,2
+np.float32,0x3f07a3ca,0x3f170572,2
+np.float32,0x3f2c7026,0x3f513935,2
+np.float32,0x3f3c4ec8,0x3f70d67c,2
+np.float32,0xbee9cce8,0xbefc724f,2
+np.float32,0xbe53ca60,0xbe56e3f3,2
+np.float32,0x3dd9e9a0,0x3ddabd98,2
+np.float32,0x3f38b8d4,0x3f69319b,2
+np.float32,0xbe176dc4,0xbe188c1d,2
+np.float32,0xbf322f2e,0xbf5c0c51,2
+np.float32,0xbe9b8676,0xbea097a2,2
+np.float32,0xbca44280,0xbca44823,2
+np.float32,0xbe2b0248,0xbe2ca036,2
+np.float32,0x3d101e80,0x3d102dbd,2
+np.float32,0xbf4eb610,0xbf8f526d,2
+np.float32,0xbec32a50,0xbecd89d1,2
+np.float32,0x3d549100,0x3d54c1ee,2
+np.float32,0x3f78e55e,0x40087025,2
+np.float32,0x3e592798,0x3e5c802d,2
+np.float32,0x3de045d0,0x3de12cfb,2
+np.float32,0xbdad28e0,0xbdad92f7,2
+np.float32,0x3e9a69e0,0x3e9f5e59,2
+np.float32,0x3e809778,0x3e836716,2
+np.float32,0xbf3278d9,0xbf5c9b6d,2
+np.float32,0x3f39fa00,0x3f6bd4a5,2
+np.float32,0xbec8143c,0xbed34ffa,2
+np.float32,0x3ddb7f40,0x3ddc57e6,2
+np.float32,0x3f0e8342,0x3f20c634,2
+np.float32,0x3f353dda,0x3f6213a4,2
+np.float32,0xbe96b400,0xbe9b4bea,2
+np.float32,0x3e626580,0x3e66328a,2
+np.float32,0xbde091c8,0xbde179df,2
+np.float32,0x3eb47b5c,0x3ebc91ca,2
+np.float32,0xbf282182,0xbf497f2f,2
+np.float32,0x3ea9f64c,0x3eb0a748,2
+np.float32,0x3f28dd4e,0x3f4aca86,2
+np.float32,0xbf71de18,0xbfe3f587,2
+np.float32,0x7fa00000,0x7fe00000,2
+np.float32,0xbf6696a6,0xbfbcf11a,2
+np.float32,0xbc853ae0,0xbc853de2,2
+np.float32,0xbeced246,0xbedb51b8,2
+np.float32,0x3f3472a4,0x3f607e00,2
+np.float32,0xbee90124,0xbefb7117,2
+np.float32,0x3eb45b90,0x3ebc6d7c,2
+np.float32,0xbe53ead0,0xbe5705d6,2
+np.float32,0x3f630c80,0x3fb420e2,2
+np.float32,0xbf408cd0,0xbf7a56a2,2
+np.float32,0x3dda4ed0,0x3ddb23f1,2
+np.float32,0xbf37ae88,0xbf67096b,2
+np.float32,0xbdd48c28,0xbdd550c9,2
+np.float32,0xbf5745b0,0xbf9cb4a4,2
+np.float32,0xbf44e6fc,0xbf8255c1,2
+np.float32,0x3f5c8e6a,0x3fa65020,2
+np.float32,0xbea45fe8,0xbeaa6630,2
+np.float32,0x3f08bdee,0x3f188ef5,2
+np.float32,0x3ec77e74,0x3ed29f4b,2
+np.float32,0xbf1a1d3c,0xbf324029,2
+np.float32,0x3cad7340,0x3cad79e3,2
+np.float32,0xbf4fac2e,0xbf90b72a,2
+np.float32,0x3f58516e,0x3f9e8330,2
+np.float32,0x3f442008,0x3f816391,2
+np.float32,0xbf6e0c6c,0xbfd42854,2
+np.float32,0xbf266f7a,0xbf4689b2,2
+np.float32,0x3eb7e2f0,0x3ec077ba,2
+np.float32,0xbf320fd0,0xbf5bcf83,2
+np.float32,0xbf6a76b9,0xbfc80a11,2
+np.float32,0xbf2a91b4,0xbf4dd526,2
+np.float32,0x3f176e30,0x3f2e150e,2
+np.float32,0xbdcccad0,0xbdcd7a9c,2
+np.float32,0x3f60a8a4,0x3faebbf7,2
+np.float32,0x3d9706f0,0x3d974d40,2
+np.float32,0x3ef3cd34,0x3f049d58,2
+np.float32,0xbf73c615,0xbfed79fe,2
+np.float32,0x3df1b170,0x3df2d31b,2
+np.float32,0x3f632a46,0x3fb466c7,2
+np.float32,0xbf3ea18e,0xbf75f9ce,2
+np.float32,0xbf3ea05c,0xbf75f71f,2
+np.float32,0xbdd76750,0xbdd83403,2
+np.float32,0xbca830c0,0xbca836cd,2
+np.float32,0x3f1d4162,0x3f373c59,2
+np.float32,0x3c115700,0x3c1157fa,2
+np.float32,0x3dae8ab0,0x3daef758,2
+np.float32,0xbcad5020,0xbcad56bf,2
+np.float32,0x3ee299c4,0x3ef36c15,2
+np.float32,0xbf7f566c,0xc054c3bd,2
+np.float32,0x3f0cc698,0x3f1e4557,2
+np.float32,0xbe75c648,0xbe7aaa04,2
+np.float32,0x3ea29238,0x3ea86417,2
+np.float32,0x3f09d9c0,0x3f1a1d61,2
+np.float32,0x3f67275c,0x3fbe74b3,2
+np.float32,0x3e1a4e18,0x3e1b7d3a,2
+np.float32,0xbef6e3fc,0xbf069e98,2
+np.float32,0xbf6038ac,0xbfadc9fd,2
+np.float32,0xbe46bdd4,0xbe494b7f,2
+np.float32,0xbf4df1f4,0xbf8e3a98,2
+np.float32,0x3d094dc0,0x3d095aed,2
+np.float32,0x3f44c7d2,0x3f822fa3,2
+np.float32,0xbea30816,0xbea8e737,2
+np.float32,0xbe3c27c4,0xbe3e511b,2
+np.float32,0x3f3bb47c,0x3f6f8789,2
+np.float32,0xbe423760,0xbe4498c3,2
+np.float32,0x3ece1a74,0x3eda7634,2
+np.float32,0x3f14d1f6,0x3f2a1a89,2
+np.float32,0xbf4d9e8f,0xbf8dc4c1,2
+np.float32,0xbe92968e,0xbe96cd7f,2
+np.float32,0x3e99e6c0,0x3e9ece26,2
+np.float32,0xbf397361,0xbf6ab878,2
+np.float32,0xbf4fcea4,0xbf90e99f,2
+np.float32,0x3de37640,0x3de46779,2
+np.float32,0x3eb1b604,0x3eb9698c,2
+np.float32,0xbf52d0a2,0xbf957361,2
+np.float32,0xbe20435c,0xbe21975a,2
+np.float32,0x3f437a58,0x3f809bf1,2
+np.float32,0x3f27d1cc,0x3f48f335,2
+np.float32,0x3f7d4ff2,0x4027d1e2,2
+np.float32,0xbef732e4,0xbf06d205,2
+np.float32,0x3f4a0ae6,0x3f88e18e,2
+np.float32,0x3f800000,0x7f800000,2
+np.float32,0x3e3e56a0,0x3e4093ba,2
+np.float32,0xbed2fcfa,0xbee0517d,2
+np.float32,0xbe0e0114,0xbe0eecd7,2
+np.float32,0xbe808574,0xbe8353db,2
+np.float32,0x3f572e2a,0x3f9c8c86,2
+np.float32,0x80800000,0x80800000,2
+np.float32,0x3f3f3c82,0x3f775703,2
+np.float32,0xbf6e2482,0xbfd4818b,2
+np.float32,0xbf3943b0,0xbf6a5439,2
+np.float32,0x3f6e42ac,0x3fd4f1ea,2
+np.float32,0x3eb676c4,0x3ebed619,2
+np.float32,0xbe5e56c4,0xbe61ef6c,2
+np.float32,0x3eea200c,0x3efcdb65,2
+np.float32,0x3e3d2c78,0x3e3f5ef8,2
+np.float32,0xbdfd8fb0,0xbdfede71,2
+np.float32,0xbee69c8a,0xbef86e89,2
+np.float32,0x3e9efca0,0x3ea46a1c,2
+np.float32,0x3e4c2498,0x3e4ee9ee,2
+np.float32,0xbf3cc93c,0xbf71e21d,2
+np.float32,0x3ee0d77c,0x3ef13d2b,2
+np.float32,0xbefbcd2a,0xbf09d6a3,2
+np.float32,0x3f6dbe5c,0x3fd30a3e,2
+np.float32,0x3dae63e0,0x3daed03f,2
+np.float32,0xbd5001e0,0xbd502fb9,2
+np.float32,0x3f59632a,0x3fa067c8,2
+np.float32,0x3f0d355a,0x3f1ee452,2
+np.float32,0x3f2cbe5c,0x3f51c896,2
+np.float32,0x3c5e6e80,0x3c5e7200,2
+np.float32,0xbe8ac49c,0xbe8e52f0,2
+np.float32,0x3f54e576,0x3f98c0e6,2
+np.float32,0xbeaa0762,0xbeb0ba7c,2
+np.float32,0x3ec81e88,0x3ed35c21,2
+np.float32,0x3f5a6738,0x3fa23fb6,2
+np.float32,0xbf24a682,0xbf43784a,2
+np.float32,0x1,0x1,2
+np.float32,0x3ee6bc24,0x3ef89630,2
+np.float32,0x3f19444a,0x3f30ecf5,2
+np.float32,0x3ec1fc70,0x3ecc28fc,2
+np.float32,0xbf706e14,0xbfdd92fb,2
+np.float32,0x3eccb630,0x3ed8cd98,2
+np.float32,0xbcdf7aa0,0xbcdf88d3,2
+np.float32,0xbe450da8,0xbe478a8e,2
+np.float32,0x3ec9c210,0x3ed54c0b,2
+np.float32,0xbf3b86ca,0xbf6f24d1,2
+np.float32,0x3edcc7a0,0x3eec3a5c,2
+np.float32,0x3f075d5c,0x3f16a39a,2
+np.float32,0xbf5719ce,0xbf9c69de,2
+np.float32,0x3f62cb22,0x3fb3885a,2
+np.float32,0x3f639216,0x3fb55c93,2
+np.float32,0xbf473ee7,0xbf85413a,2
+np.float32,0xbf01b66c,0xbf0eea86,2
+np.float32,0x3e872d80,0x3e8a74f8,2
+np.float32,0xbf60957e,0xbfae925c,2
+np.float32,0xbf6847b2,0xbfc1929b,2
+np.float32,0x3f78bb94,0x4007b363,2
+np.float32,0xbf47efdb,0xbf8622db,2
+np.float32,0xbe1f2308,0xbe206fd6,2
+np.float32,0xbf414926,0xbf7c0a7e,2
+np.float32,0x3eecc268,0x3f00194d,2
+np.float32,0x3eb086d0,0x3eb81120,2
+np.float32,0xbef1af80,0xbf033ff5,2
+np.float32,0xbf454e56,0xbf82d4aa,2
+np.float32,0x3e622560,0x3e65ef20,2
+np.float32,0x3f50d2b2,0x3f926a83,2
+np.float32,0x3eb2c45c,0x3eba9d2c,2
+np.float32,0x3e42d1a0,0x3e4538c9,2
+np.float32,0xbf24cc5c,0xbf43b8e3,2
+np.float32,0x3e8c6464,0x3e90141a,2
+np.float32,0xbf3abff2,0xbf6d79c5,2
+np.float32,0xbec8f2e6,0xbed456fa,2
+np.float32,0xbf787b38,0xc00698b4,2
+np.float32,0xbf58d5cd,0xbf9f6c03,2
+np.float32,0x3df4ee20,0x3df61ba8,2
+np.float32,0xbf34581e,0xbf604951,2
+np.float32,0xbeba5cf4,0xbec35119,2
+np.float32,0xbf76c22d,0xbfffc51c,2
+np.float32,0x3ef63b2c,0x3f0630b4,2
+np.float32,0x3eeadb64,0x3efdc877,2
+np.float32,0x3dfd8c70,0x3dfedb24,2
+np.float32,0x3f441600,0x3f81576d,2
+np.float32,0x3f23a0d8,0x3f41bbf6,2
+np.float32,0x3cb84d40,0x3cb85536,2
+np.float32,0xbf25cb5c,0xbf456e38,2
+np.float32,0xbc108540,0xbc108636,2
+np.float32,0xbc5b9140,0xbc5b949e,2
+np.float32,0xbf62ff40,0xbfb401dd,2
+np.float32,0x3e8e0710,0x3e91d93e,2
+np.float32,0x3f1b6ae0,0x3f344dfd,2
+np.float32,0xbf4dbbbe,0xbf8dedea,2
+np.float32,0x3f1a5fb2,0x3f32a880,2
+np.float32,0xbe56bd00,0xbe59f8cb,2
+np.float32,0xbf490a5c,0xbf87902d,2
+np.float32,0xbf513072,0xbf92f717,2
+np.float32,0x3e73ee28,0x3e78b542,2
+np.float32,0x3f0a4c7a,0x3f1abf2c,2
+np.float32,0x3e10d5c8,0x3e11d00b,2
+np.float32,0xbf771aac,0xc001207e,2
+np.float32,0x3efe2f54,0x3f0b6a46,2
+np.float32,0xbea5f3ea,0xbeac291f,2
+np.float32,0xbf1a73e8,0xbf32c845,2
+np.float32,0x3ebcc82c,0x3ec61c4f,2
+np.float32,0xbf24f492,0xbf43fd9a,2
+np.float32,0x3ecbd908,0x3ed7c691,2
+np.float32,0x3f461c5e,0x3f83d3f0,2
+np.float32,0x3eed0524,0x3f0043c1,2
+np.float32,0x3d06e840,0x3d06f4bf,2
+np.float32,0x3eb6c974,0x3ebf34d7,2
+np.float32,0xbf1c85e1,0xbf36100f,2
+np.float32,0x3ed697d0,0x3ee4ad04,2
+np.float32,0x3eab0484,0x3eb1d733,2
+np.float32,0xbf3b02f2,0xbf6e0935,2
+np.float32,0xbeeab154,0xbefd9334,2
+np.float32,0xbf695372,0xbfc49881,2
+np.float32,0x3e8aaa7c,0x3e8e36be,2
+np.float32,0xbf208754,0xbf3c8f7b,2
+np.float32,0xbe0dbf28,0xbe0ea9a1,2
+np.float32,0x3ca780c0,0x3ca786ba,2
+np.float32,0xbeb320b4,0xbebb065e,2
+np.float32,0x3f13c698,0x3f288821,2
+np.float32,0xbe8cbbec,0xbe9072c4,2
+np.float32,0x3f1ed534,0x3f39c8df,2
+np.float32,0x3e1ca450,0x3e1de190,2
+np.float32,0x3f54be1c,0x3f988134,2
+np.float32,0x3f34e4ee,0x3f6161b4,2
+np.float32,0xbf7e6913,0xc038b246,2
+np.float32,0x3d3c3f20,0x3d3c6119,2
+np.float32,0x3ca9dc80,0x3ca9e2bc,2
+np.float32,0xbf577ea2,0xbf9d161a,2
+np.float32,0xbedb22c8,0xbeea3644,2
+np.float32,0x3f22a044,0x3f400bfa,2
+np.float32,0xbe214b8c,0xbe22a637,2
+np.float32,0x3e8cd300,0x3e908bbc,2
+np.float32,0xbec4d214,0xbecf7a58,2
+np.float32,0x3e9399a4,0x3e97e7e4,2
+np.float32,0xbee6a1a2,0xbef874ed,2
+np.float32,0xbf323742,0xbf5c1bfd,2
+np.float32,0x3f48b882,0x3f8725ac,2
+np.float32,0xbf4d4dba,0xbf8d532e,2
+np.float32,0xbf59640a,0xbfa0695a,2
+np.float32,0xbf2ad562,0xbf4e4f03,2
+np.float32,0x3e317d98,0x3e334d03,2
+np.float32,0xbf6a5b71,0xbfc7b5a2,2
+np.float32,0x3e87b434,0x3e8b05cf,2
+np.float32,0xbf1c344c,0xbf358dee,2
+np.float32,0x3e449428,0x3e470c65,2
+np.float32,0xbf2c0f2f,0xbf508808,2
+np.float32,0xbec5b5ac,0xbed0859c,2
+np.float32,0xbf4aa956,0xbf89b4b1,2
+np.float32,0x3f6dd374,0x3fd35717,2
+np.float32,0x3f45f76c,0x3f83a5ef,2
+np.float32,0xbed1fba8,0xbedf1bd5,2
+np.float32,0xbd26b2d0,0xbd26ca66,2
+np.float32,0xbe9817c2,0xbe9cd1c3,2
+np.float32,0x3e725988,0x3e770875,2
+np.float32,0xbf1a8ded,0xbf32f132,2
+np.float32,0xbe695860,0xbe6d83d3,2
+np.float32,0x3d8cecd0,0x3d8d25ea,2
+np.float32,0x3f574706,0x3f9cb6ec,2
+np.float32,0xbf5c5a1f,0xbfa5eaf3,2
+np.float32,0x3e7a7c88,0x3e7fab83,2
+np.float32,0xff800000,0xffc00000,2
+np.float32,0x3f66396a,0x3fbbfbb0,2
+np.float32,0x3ed6e588,0x3ee50b53,2
+np.float32,0xbb56d500,0xbb56d532,2
+np.float32,0x3ebd23fc,0x3ec6869a,2
+np.float32,0xbf70d490,0xbfdf4af5,2
+np.float32,0x3e514f88,0x3e544d15,2
+np.float32,0x3e660f98,0x3e6a0dac,2
+np.float32,0xbf034da1,0xbf1110bb,2
+np.float32,0xbf60d9be,0xbfaf2714,2
+np.float32,0x3df67b10,0x3df7ae64,2
+np.float32,0xbeeedc0a,0xbf017010,2
+np.float32,0xbe149224,0xbe15a072,2
+np.float32,0x3f455084,0x3f82d759,2
+np.float32,0x3f210f9e,0x3f3d7093,2
+np.float32,0xbeaea3e0,0xbeb5edd3,2
+np.float32,0x3e0724b0,0x3e07efad,2
+np.float32,0x3f09a784,0x3f19d6ac,2
+np.float32,0xbf044340,0xbf125ee8,2
+np.float32,0xbf71adc9,0xbfe315fe,2
+np.float32,0x3efd3870,0x3f0ac6a8,2
+np.float32,0xbf53c7a6,0xbf96f6df,2
+np.float32,0xbf3cf784,0xbf7247af,2
+np.float32,0x3e0ce9e0,0x3e0dd035,2
+np.float32,0xbd3051a0,0xbd306d89,2
+np.float32,0x3ecab804,0x3ed66f77,2
+np.float32,0x3e984350,0x3e9d0189,2
+np.float32,0x3edd1c00,0x3eeca20b,2
+np.float32,0xbe8e22a0,0xbe91f71b,2
+np.float32,0x3ebebc18,0x3ec85fd6,2
+np.float32,0xba275c00,0xba275c01,2
+np.float32,0x3f1d8190,0x3f37a385,2
+np.float32,0x3f17343e,0x3f2dbbfe,2
+np.float32,0x3caa8000,0x3caa864e,2
+np.float32,0x3e7a7308,0x3e7fa168,2
+np.float32,0x3f7359a6,0x3feb3e1a,2
+np.float32,0xbf7ad15a,0xc012a743,2
+np.float32,0xbf122efb,0xbf262812,2
+np.float32,0xbf03ba04,0xbf11a3fa,2
+np.float32,0x3ed7a90c,0x3ee5f8d4,2
+np.float32,0xbe23e318,0xbe254eed,2
+np.float32,0xbe2866f4,0xbe29f20a,2
+np.float32,0xbeaedff2,0xbeb631d0,2
+np.float32,0x0,0x0,2
+np.float32,0x3ef2a034,0x3f03dafd,2
+np.float32,0x3f35806c,0x3f62994e,2
+np.float32,0xbf655e19,0xbfb9c718,2
+np.float32,0x3f5d54ce,0x3fa7d4f4,2
+np.float32,0x3f33e64a,0x3f5f67e3,2
+np.float32,0x3ebf4010,0x3ec8f923,2
+np.float32,0xbe050dc8,0xbe05cf70,2
+np.float32,0x3f61693e,0x3fb063b0,2
+np.float32,0xbd94ac00,0xbd94ef12,2
+np.float32,0x3e9de008,0x3ea32f61,2
+np.float32,0xbe3d042c,0xbe3f3540,2
+np.float32,0x3e8fdfc0,0x3e93d9e4,2
+np.float32,0x3f28bc48,0x3f4a9019,2
+np.float32,0x3edea928,0x3eee8b09,2
+np.float32,0xbf05f673,0xbf14b362,2
+np.float32,0xbf360730,0xbf63a914,2
+np.float32,0xbe3fb454,0xbe41fe0a,2
+np.float32,0x3f6d99a8,0x3fd28552,2
+np.float32,0xbf3ae866,0xbf6dd052,2
+np.float32,0x3f5b1164,0x3fa37aec,2
+np.float32,0xbf64a451,0xbfb7f61b,2
+np.float32,0xbdd79bd0,0xbdd86919,2
+np.float32,0x3e89fc00,0x3e8d7a85,2
+np.float32,0x3f4bf690,0x3f8b77ea,2
+np.float32,0x3cbdf280,0x3cbdfb38,2
+np.float32,0x3f138f98,0x3f2835b4,2
+np.float32,0xbe33967c,0xbe3576bc,2
+np.float32,0xbf298164,0xbf4bedda,2
+np.float32,0x3e9955cc,0x3e9e2edb,2
+np.float32,0xbf79b383,0xc00c56c0,2
+np.float32,0x3ea0834c,0x3ea61aea,2
+np.float32,0xbf511184,0xbf92c89a,2
+np.float32,0x3f4d9fba,0x3f8dc666,2
+np.float32,0x3f3387c2,0x3f5ead80,2
+np.float32,0x3e3f7360,0x3e41babb,2
+np.float32,0xbf3cc4d6,0xbf71d879,2
+np.float32,0x3f2e4402,0x3f54994e,2
+np.float32,0x3e6a7118,0x3e6eabff,2
+np.float32,0xbf05d83e,0xbf1489cc,2
+np.float32,0xbdce4fd8,0xbdcf039a,2
+np.float32,0xbf03e2f4,0xbf11dbaf,2
+np.float32,0x3f1ea0a0,0x3f397375,2
+np.float32,0x3f7aff54,0x4013cb1b,2
+np.float32,0x3f5ef158,0x3fab1801,2
+np.float32,0xbe33bcc8,0xbe359e40,2
+np.float32,0xbf04dd0e,0xbf133111,2
+np.float32,0xbf14f887,0xbf2a54d1,2
+np.float32,0x3f75c37a,0x3ff9196e,2
+np.float32,0x3f35c3c8,0x3f6320f2,2
+np.float32,0x3f53bb94,0x3f96e3c3,2
+np.float32,0x3f4d473e,0x3f8d4a19,2
+np.float32,0xbdfe19e0,0xbdff6ac9,2
+np.float32,0xbf7f0cc4,0xc049342d,2
+np.float32,0xbdbfc778,0xbdc057bb,2
+np.float32,0xbf7575b7,0xbff73067,2
+np.float32,0xbe9df488,0xbea34609,2
+np.float32,0xbefbd3c6,0xbf09daff,2
+np.float32,0x3f19962c,0x3f316cbd,2
+np.float32,0x3f7acec6,0x40129732,2
+np.float32,0xbf5db7de,0xbfa89a21,2
+np.float32,0x3f62f444,0x3fb3e830,2
+np.float32,0xbf522adb,0xbf94737f,2
+np.float32,0xbef6ceb2,0xbf0690ba,2
+np.float32,0xbf57c41e,0xbf9d8db0,2
+np.float32,0x3eb3360c,0x3ebb1eb0,2
+np.float32,0x3f29327e,0x3f4b618e,2
+np.float32,0xbf08d099,0xbf18a916,2
+np.float32,0x3ea21014,0x3ea7d369,2
+np.float32,0x3f39e516,0x3f6ba861,2
+np.float32,0x3e7c4f28,0x3e80ce08,2
+np.float32,0xbec5a7f8,0xbed07582,2
+np.float32,0xbf0b1b46,0xbf1be3e7,2
+np.float32,0xbef0e0ec,0xbf02bb2e,2
+np.float32,0x3d835a30,0x3d838869,2
+np.float32,0x3f08aa40,0x3f18736e,2
+np.float32,0x3eb0e4c8,0x3eb87bcd,2
+np.float32,0x3eb3821c,0x3ebb7564,2
+np.float32,0xbe3a7320,0xbe3c8d5a,2
+np.float32,0x3e43f8c0,0x3e466b10,2
+np.float32,0x3e914288,0x3e955b69,2
+np.float32,0x3ec7d800,0x3ed308e7,2
+np.float32,0x3e603df8,0x3e63eef2,2
+np.float32,0x3f225cac,0x3f3f9ac6,2
+np.float32,0x3e3db8f0,0x3e3ff06b,2
+np.float32,0x3f358d78,0x3f62b38c,2
+np.float32,0xbed9bd64,0xbee88158,2
+np.float32,0x800000,0x800000,2
+np.float32,0x3f1adfce,0x3f337230,2
+np.float32,0xbefdc346,0xbf0b229d,2
+np.float32,0xbf091018,0xbf190208,2
+np.float32,0xbf800000,0xff800000,2
+np.float32,0x3f27c2c4,0x3f48d8db,2
+np.float32,0x3ef59c80,0x3f05c993,2
+np.float32,0x3e18a340,0x3e19c893,2
+np.float32,0x3f209610,0x3f3ca7c5,2
+np.float32,0x3f69cc22,0x3fc60087,2
+np.float32,0xbf66cf07,0xbfbd8721,2
+np.float32,0xbf768098,0xbffdfcc4,2
+np.float32,0x3df27a40,0x3df39ec4,2
+np.float32,0x3daf5bd0,0x3dafca02,2
+np.float32,0x3f53f2be,0x3f973b41,2
+np.float32,0xbf7edcbc,0xc0436ce3,2
+np.float32,0xbdf61db8,0xbdf74fae,2
+np.float32,0x3e2c9328,0x3e2e3cb2,2
+np.float32,0x3f1a4570,0x3f327f41,2
+np.float32,0xbf766306,0xbffd32f1,2
+np.float32,0xbf468b9d,0xbf845f0f,2
+np.float32,0x3e398970,0x3e3b9bb1,2
+np.float32,0xbbefa900,0xbbefaa18,2
+np.float32,0xbf54c989,0xbf9893ad,2
+np.float32,0x3f262cf6,0x3f46169d,2
+np.float32,0x3f638a8a,0x3fb54a98,2
+np.float32,0xbeb36c78,0xbebb5cb8,2
+np.float32,0xbeac4d42,0xbeb34993,2
+np.float32,0x3f1d1942,0x3f36fbf2,2
+np.float32,0xbf5d49ba,0xbfa7bf07,2
+np.float32,0xbf182b5c,0xbf2f38d0,2
+np.float32,0x3f41a742,0x3f7ce5ef,2
+np.float32,0x3f0b9a6c,0x3f1c9898,2
+np.float32,0x3e847494,0x3e8788f3,2
+np.float32,0xbde41608,0xbde50941,2
+np.float32,0x3f693944,0x3fc44b5a,2
+np.float32,0x3f0386b2,0x3f115e37,2
+np.float32,0x3f3a08b0,0x3f6bf3c1,2
+np.float32,0xbf78ee64,0xc0089977,2
+np.float32,0xbf013a11,0xbf0e436e,2
+np.float32,0x3f00668e,0x3f0d2836,2
+np.float32,0x3e6d9850,0x3e720081,2
+np.float32,0x3eacf578,0x3eb4075d,2
+np.float32,0x3f18aef8,0x3f3004b4,2
+np.float32,0x3de342f0,0x3de43385,2
+np.float32,0x3e56cee8,0x3e5a0b85,2
+np.float32,0xbf287912,0xbf4a1966,2
+np.float32,0x3e92c948,0x3e9704c2,2
+np.float32,0x3c07d080,0x3c07d14c,2
+np.float32,0xbe90f6a0,0xbe9508e0,2
+np.float32,0x3e8b4f28,0x3e8ee884,2
+np.float32,0xbf35b56c,0xbf6303ff,2
+np.float32,0xbef512b8,0xbf057027,2
+np.float32,0x3e36c630,0x3e38c0cd,2
+np.float32,0x3f0b3ca8,0x3f1c134a,2
+np.float32,0x3e4cd610,0x3e4fa2c5,2
+np.float32,0xbf5a8372,0xbfa273a3,2
+np.float32,0xbecaad3c,0xbed662ae,2
+np.float32,0xbec372d2,0xbecddeac,2
+np.float32,0x3f6fb2b2,0x3fda8a22,2
+np.float32,0x3f365f28,0x3f645b5a,2
+np.float32,0xbecd00fa,0xbed926a4,2
+np.float32,0xbebafa32,0xbec40672,2
+np.float32,0xbf235b73,0xbf4146c4,2
+np.float32,0x3f7a4658,0x400f6e2c,2
+np.float32,0x3f35e824,0x3f636a54,2
+np.float32,0x3cb87640,0x3cb87e3c,2
+np.float32,0xbf296288,0xbf4bb6ee,2
+np.float32,0x7f800000,0xffc00000,2
+np.float32,0xbf4de86e,0xbf8e2d1a,2
+np.float32,0xbf4ace12,0xbf89e5f3,2
+np.float32,0x3d65a300,0x3d65e0b5,2
+np.float32,0xbe10c534,0xbe11bf21,2
+np.float32,0xbeba3c1c,0xbec32b3e,2
+np.float32,0x3e87eaf8,0x3e8b40b8,2
+np.float32,0x3d5c3bc0,0x3d5c722d,2
+np.float32,0x3e8c14b8,0x3e8fbdf8,2
+np.float32,0xbf06c6f0,0xbf15d327,2
+np.float32,0xbe0f1e30,0xbe100f96,2
+np.float32,0xbee244b0,0xbef30251,2
+np.float32,0x3f2a21b0,0x3f4d0c1d,2
+np.float32,0xbf5f7f81,0xbfac408e,2
+np.float32,0xbe3dba2c,0xbe3ff1b2,2
+np.float32,0x3f3ffc22,0x3f790abf,2
+np.float32,0x3edc3dac,0x3eeb90fd,2
+np.float32,0x7f7fffff,0xffc00000,2
+np.float32,0x3ecfaaac,0x3edc5485,2
+np.float32,0x3f0affbe,0x3f1bbcd9,2
+np.float32,0x3f5f2264,0x3fab7dca,2
+np.float32,0x3f37394c,0x3f66186c,2
+np.float32,0xbe6b2f6c,0xbe6f74e3,2
+np.float32,0x3f284772,0x3f49c1f1,2
+np.float32,0xbdf27bc8,0xbdf3a051,2
+np.float32,0xbc8b14e0,0xbc8b184c,2
+np.float32,0x3f6a867c,0x3fc83b07,2
+np.float32,0x3f1ec876,0x3f39b429,2
+np.float32,0x3f6fd9a8,0x3fdb28d6,2
+np.float32,0xbf473cca,0xbf853e8c,2
+np.float32,0x3e23eff8,0x3e255c23,2
+np.float32,0x3ebefdfc,0x3ec8ac5d,2
+np.float32,0x3f6c8c22,0x3fced2b1,2
+np.float32,0x3f168388,0x3f2cad44,2
+np.float32,0xbece2410,0xbeda81ac,2
+np.float32,0x3f5532f0,0x3f993eea,2
+np.float32,0x3ef1938c,0x3f032dfa,2
+np.float32,0xbef05268,0xbf025fba,2
+np.float32,0x3f552e4a,0x3f993754,2
+np.float32,0x3e9ed068,0x3ea4392d,2
+np.float32,0xbe1a0c24,0xbe1b39be,2
+np.float32,0xbf2623aa,0xbf46068c,2
+np.float32,0xbe1cc300,0xbe1e00fc,2
+np.float32,0xbe9c0576,0xbea12397,2
+np.float32,0xbd827338,0xbd82a07e,2
+np.float32,0x3f0fc31a,0x3f229786,2
+np.float32,0x3e577810,0x3e5abc7d,2
+np.float32,0x3e0e1cb8,0x3e0f0906,2
+np.float32,0x3e84d344,0x3e87ee73,2
+np.float32,0xbf39c45e,0xbf6b6337,2
+np.float32,0x3edfb25c,0x3eefd273,2
+np.float32,0x3e016398,0x3e021596,2
+np.float32,0xbefeb1be,0xbf0bc0de,2
+np.float32,0x3f37e104,0x3f677196,2
+np.float32,0x3f545316,0x3f97d500,2
+np.float32,0xbefc165a,0xbf0a06ed,2
+np.float32,0xbf0923e6,0xbf191dcd,2
+np.float32,0xbf386508,0xbf68831f,2
+np.float32,0xbf3d4630,0xbf72f4e1,2
+np.float32,0x3f3dbe82,0x3f73ff13,2
+np.float32,0xbf703de4,0xbfdcc7e2,2
+np.float32,0xbf531482,0xbf95dd1a,2
+np.float32,0xbf0af1b6,0xbf1ba8f4,2
+np.float32,0xbec8fd9c,0xbed463a4,2
+np.float32,0xbe230320,0xbe24691a,2
+np.float32,0xbf7de541,0xc02faf38,2
+np.float32,0x3efd2360,0x3f0ab8b7,2
+np.float32,0x3db7f350,0x3db87291,2
+np.float32,0x3e74c510,0x3e799924,2
+np.float32,0x3da549c0,0x3da5a5fc,2
+np.float32,0x3e8a3bc4,0x3e8dbf4a,2
+np.float32,0xbf69f086,0xbfc66e84,2
+np.float32,0x3f323f8e,0x3f5c2c17,2
+np.float32,0x3ec0ae3c,0x3ecaa334,2
+np.float32,0xbebe8966,0xbec824fc,2
+np.float32,0x3f34691e,0x3f606b13,2
+np.float32,0x3f13790e,0x3f2813f5,2
+np.float32,0xbf61c027,0xbfb12618,2
+np.float32,0x3e90c690,0x3e94d4a1,2
+np.float32,0xbefce8f0,0xbf0a920e,2
+np.float32,0xbf5c0e8a,0xbfa559a7,2
+np.float32,0x3f374f60,0x3f6645b6,2
+np.float32,0x3f25f6fa,0x3f45b967,2
+np.float32,0x3f2421aa,0x3f42963a,2
+np.float32,0x3ebfa328,0x3ec96c57,2
+np.float32,0x3e3bef28,0x3e3e1685,2
+np.float32,0x3ea3fa3c,0x3ea9f4dd,2
+np.float32,0x3f362b8e,0x3f63f2b2,2
+np.float32,0xbedcef18,0xbeec6ada,2
+np.float32,0xbdd29c88,0xbdd35bd0,2
+np.float32,0x3f261aea,0x3f45f76f,2
+np.float32,0xbe62c470,0xbe66965e,2
+np.float32,0x7fc00000,0x7fc00000,2
+np.float32,0xbee991aa,0xbefc277b,2
+np.float32,0xbf571960,0xbf9c6923,2
+np.float32,0xbe6fb410,0xbe743b41,2
+np.float32,0x3eb1bed0,0x3eb9738d,2
+np.float32,0x80000000,0x80000000,2
+np.float32,0x3eddcbe4,0x3eed7a69,2
+np.float32,0xbf2a81ba,0xbf4db86d,2
+np.float32,0x3f74da54,0x3ff38737,2
+np.float32,0xbeb6bff4,0xbebf29f4,2
+np.float32,0x3f445752,0x3f81a698,2
+np.float32,0x3ed081b4,0x3edd5618,2
+np.float32,0xbee73802,0xbef931b4,2
+np.float32,0xbd13f2a0,0xbd14031c,2
+np.float32,0xbb4d1200,0xbb4d122c,2
+np.float32,0xbee8777a,0xbefac393,2
+np.float32,0x3f42047c,0x3f7dc06c,2
+np.float32,0xbd089270,0xbd089f67,2
+np.float32,0xbf628c16,0xbfb2f66b,2
+np.float32,0x3e72e098,0x3e77978d,2
+np.float32,0x3ed967cc,0x3ee818e4,2
+np.float32,0x3e284c80,0x3e29d6d9,2
+np.float32,0x3f74e8ba,0x3ff3dbef,2
+np.float32,0x3f013e86,0x3f0e4969,2
+np.float32,0xbf610d4f,0xbfaf983c,2
+np.float32,0xbf3c8d36,0xbf715eba,2
+np.float32,0xbedbc756,0xbeeaffdb,2
+np.float32,0x3e143ec8,0x3e154b4c,2
+np.float32,0xbe1c9808,0xbe1dd4fc,2
+np.float32,0xbe887a1e,0xbe8bdac5,2
+np.float32,0xbe85c4bc,0xbe88f17a,2
+np.float32,0x3f35967e,0x3f62c5b4,2
+np.float32,0x3ea2c4a4,0x3ea89c2d,2
+np.float32,0xbc8703c0,0xbc8706e1,2
+np.float32,0xbf13d52c,0xbf289dff,2
+np.float32,0xbf63bb56,0xbfb5bf29,2
+np.float32,0xbf61c5ef,0xbfb13319,2
+np.float32,0xbf128410,0xbf26a675,2
+np.float32,0x3f03fcf2,0x3f11ff13,2
+np.float32,0xbe49c924,0xbe4c75cd,2
+np.float32,0xbf211a9c,0xbf3d82c5,2
+np.float32,0x3f7e9d52,0x403d1b42,2
+np.float32,0x3edfefd4,0x3ef01e71,2
+np.float32,0x3ebc5bd8,0x3ec59efb,2
+np.float32,0x3d7b02e0,0x3d7b537f,2
+np.float32,0xbf1163ba,0xbf24fb43,2
+np.float32,0x3f5072f2,0x3f91dbf1,2
+np.float32,0xbee700ce,0xbef8ec60,2
+np.float32,0x3f534168,0x3f962359,2
+np.float32,0x3e6d6c40,0x3e71d1ef,2
+np.float32,0x3def9d70,0x3df0b7a8,2
+np.float32,0x3e89cf80,0x3e8d4a8a,2
+np.float32,0xbf687ca7,0xbfc2290f,2
+np.float32,0x3f35e134,0x3f635c51,2
+np.float32,0x3e59eef8,0x3e5d50fa,2
+np.float32,0xbf65c9e1,0xbfbada61,2
+np.float32,0xbf759292,0xbff7e43d,2
+np.float32,0x3f4635a0,0x3f83f372,2
+np.float32,0x3f29baaa,0x3f4c53f1,2
+np.float32,0x3f6b15a6,0x3fc9fe04,2
+np.float32,0x3edabc88,0x3ee9b922,2
+np.float32,0x3ef382e0,0x3f046d4d,2
+np.float32,0xbe351310,0xbe36ff7f,2
+np.float32,0xbf05c935,0xbf14751c,2
+np.float32,0xbf0e7c50,0xbf20bc24,2
+np.float32,0xbf69bc94,0xbfc5d1b8,2
+np.float32,0xbed41aca,0xbee1aa23,2
+np.float32,0x3f518c08,0x3f938162,2
+np.float32,0xbf3d7974,0xbf73661a,2
+np.float32,0x3f1951a6,0x3f3101c9,2
+np.float32,0xbeb3f436,0xbebbf787,2
+np.float32,0xbf77a190,0xc0031d43,2
+np.float32,0x3eb5b3cc,0x3ebdf6e7,2
+np.float32,0xbed534b4,0xbee2fed2,2
+np.float32,0xbe53e1b8,0xbe56fc56,2
+np.float32,0x3f679e20,0x3fbfb91c,2
+np.float32,0xff7fffff,0xffc00000,2
+np.float32,0xbf7b9bcb,0xc0180073,2
+np.float32,0xbf5635e8,0xbf9aea15,2
+np.float32,0xbe5a3318,0xbe5d9856,2
+np.float32,0xbe003284,0xbe00df9a,2
+np.float32,0x3eb119a4,0x3eb8b7d6,2
+np.float32,0xbf3bccf8,0xbf6fbc84,2
+np.float32,0x3f36f600,0x3f658ea8,2
+np.float32,0x3f1ea834,0x3f397fc2,2
+np.float32,0xbe7cfb54,0xbe8129b3,2
+np.float32,0xbe9b3746,0xbea0406a,2
+np.float32,0x3edc0f90,0x3eeb586c,2
+np.float32,0x3e1842e8,0x3e19660c,2
+np.float32,0xbd8f10b0,0xbd8f4c70,2
+np.float32,0xbf064aca,0xbf1527a2,2
+np.float32,0x3e632e58,0x3e6705be,2
+np.float32,0xbef28ba4,0xbf03cdbb,2
+np.float32,0x3f27b21e,0x3f48bbaf,2
+np.float32,0xbe6f30d4,0xbe73b06e,2
+np.float32,0x3f3e6cb0,0x3f75834b,2
+np.float32,0xbf264aa5,0xbf4649f0,2
+np.float32,0xbf690775,0xbfc3b978,2
+np.float32,0xbf3e4a38,0xbf753632,2
+np.float64,0x3fe12bbe8c62577e,0x3fe32de8e5f961b0,2
+np.float64,0x3fc9b8909b337120,0x3fca1366da00efff,2
+np.float64,0x3feaee4245f5dc84,0x3ff3a011ea0432f3,2
+np.float64,0xbfe892c000f12580,0xbff03e5adaed6f0c,2
+np.float64,0xbf9be8de4837d1c0,0xbf9beaa367756bd1,2
+np.float64,0x3fe632e58fec65cc,0x3feb5ccc5114ca38,2
+np.float64,0x3fe78a0ef7ef141e,0x3fee1b4521d8eb6c,2
+np.float64,0x3feec27a65fd84f4,0x3fff643c8318e81e,2
+np.float64,0x3fbed6efce3dade0,0x3fbefd76cff00111,2
+np.float64,0xbfe3a05fab6740c0,0xbfe6db078aeeb0ca,2
+np.float64,0x3fdca11a56b94234,0x3fdece9e6eacff1b,2
+np.float64,0x3fe0fb15aae1f62c,0x3fe2e9e095ec2089,2
+np.float64,0x3fede12abf7bc256,0x3ffafd0ff4142807,2
+np.float64,0x3feb919edcf7233e,0x3ff4c9aa0bc2432f,2
+np.float64,0x3fd39633b5a72c68,0x3fd43c2e6d5f441c,2
+np.float64,0x3fd9efcbfeb3df98,0x3fdb83f03e58f91c,2
+np.float64,0x3fe2867a36650cf4,0x3fe525858c8ce72e,2
+np.float64,0x3fdacbb8f3b59770,0x3fdc8cd431b6e3ff,2
+np.float64,0x3fcc120503382408,0x3fcc88a8fa43e1c6,2
+np.float64,0xbfd99ff4eab33fea,0xbfdb24a20ae3687d,2
+np.float64,0xbfe8caf0157195e0,0xbff083b8dd0941d3,2
+np.float64,0x3fddc9bf92bb9380,0x3fe022aac0f761d5,2
+np.float64,0x3fe2dbb66e65b76c,0x3fe5a6e7caf3f1f2,2
+np.float64,0x3fe95f5c4a72beb8,0x3ff1444697e96138,2
+np.float64,0xbfc6b163d92d62c8,0xbfc6ef6e006658a1,2
+np.float64,0x3fdf1b2616be364c,0x3fe0fcbd2848c9e8,2
+np.float64,0xbfdca1ccf7b9439a,0xbfdecf7dc0eaa663,2
+np.float64,0x3fe078d6a260f1ae,0x3fe236a7c66ef6c2,2
+np.float64,0x3fdf471bb9be8e38,0x3fe11990ec74e704,2
+np.float64,0xbfe417626be82ec5,0xbfe79c9aa5ed2e2f,2
+np.float64,0xbfeb9cf5677739eb,0xbff4dfc24c012c90,2
+np.float64,0x3f8d9142b03b2280,0x3f8d91c9559d4779,2
+np.float64,0x3fb052c67220a590,0x3fb05873c90d1cd6,2
+np.float64,0x3fd742e2c7ae85c4,0x3fd860128947d15d,2
+np.float64,0x3fec2e2a2bf85c54,0x3ff60eb554bb8d71,2
+np.float64,0xbfeb2b8bc8f65718,0xbff40b734679497a,2
+np.float64,0x3fe25f8e0d64bf1c,0x3fe4eb381d077803,2
+np.float64,0x3fe56426256ac84c,0x3fe9dafbe79370f0,2
+np.float64,0x3feecc1e5d7d983c,0x3fffa49bedc7aa25,2
+np.float64,0xbfc88ce94b3119d4,0xbfc8dbba0fdee2d2,2
+np.float64,0xbfabcf51ac379ea0,0xbfabd6552aa63da3,2
+np.float64,0xbfccc8b849399170,0xbfcd48d6ff057a4d,2
+np.float64,0x3fd2f831e8a5f064,0x3fd38e67b0dda905,2
+np.float64,0x3fcafdcd6135fb98,0x3fcb670ae2ef4d36,2
+np.float64,0x3feda6042efb4c08,0x3ffa219442ac4ea5,2
+np.float64,0x3fed382b157a7056,0x3ff8bc01bc6d10bc,2
+np.float64,0x3fed858a50fb0b14,0x3ff9b1c05cb6cc0f,2
+np.float64,0x3fcc3960653872c0,0x3fccb2045373a3d1,2
+np.float64,0xbfec5177e478a2f0,0xbff65eb4557d94eb,2
+np.float64,0x3feafe0d5e75fc1a,0x3ff3bb4a260a0dcb,2
+np.float64,0x3fe08bc87ee11790,0x3fe25078aac99d31,2
+np.float64,0xffefffffffffffff,0xfff8000000000000,2
+np.float64,0x3f79985ce0333100,0x3f799872b591d1cb,2
+np.float64,0xbfd4001cf9a8003a,0xbfd4b14b9035b94f,2
+np.float64,0x3fe54a17e6ea9430,0x3fe9ac0f18682343,2
+np.float64,0xbfb4e07fea29c100,0xbfb4ec6520dd0689,2
+np.float64,0xbfed2b6659fa56cd,0xbff895ed57dc1450,2
+np.float64,0xbfe81fc8b5f03f92,0xbfef6b95e72a7a7c,2
+np.float64,0xbfe6aced16ed59da,0xbfec4ce131ee3704,2
+np.float64,0xbfe599f30ceb33e6,0xbfea3d07c1cd78e2,2
+np.float64,0xbfe0ff278b61fe4f,0xbfe2ef8b5efa89ed,2
+np.float64,0xbfe3e9406467d281,0xbfe750e43e841736,2
+np.float64,0x3fcc6b52cf38d6a8,0x3fcce688f4fb2cf1,2
+np.float64,0xbfc890e8133121d0,0xbfc8dfdfee72d258,2
+np.float64,0x3fe46e81dbe8dd04,0x3fe82e09783811a8,2
+np.float64,0x3fd94455e5b288ac,0x3fdab7cef2de0b1f,2
+np.float64,0xbfe82151fff042a4,0xbfef6f254c9696ca,2
+np.float64,0x3fcee1ac1d3dc358,0x3fcf80a6ed07070a,2
+np.float64,0x3fcce8f90939d1f0,0x3fcd6ad18d34f8b5,2
+np.float64,0x3fd6afe56fad5fcc,0x3fd7b7567526b1fb,2
+np.float64,0x3fb1a77092234ee0,0x3fb1ae9fe0d176fc,2
+np.float64,0xbfeb758b0d76eb16,0xbff493d105652edc,2
+np.float64,0xbfb857c24e30af88,0xbfb86aa4da3be53f,2
+np.float64,0x3fe89064eff120ca,0x3ff03b7c5b3339a8,2
+np.float64,0xbfc1bd2fef237a60,0xbfc1da99893473ed,2
+np.float64,0xbfe5ad6e2eeb5adc,0xbfea60ed181b5c05,2
+np.float64,0x3fd5a66358ab4cc8,0x3fd6899e640aeb1f,2
+np.float64,0xbfe198e832e331d0,0xbfe3c8c9496d0de5,2
+np.float64,0xbfdaa5c0d7b54b82,0xbfdc5ed7d3c5ce49,2
+np.float64,0x3fcceccb6939d998,0x3fcd6ed88c2dd3a5,2
+np.float64,0xbfe44413eae88828,0xbfe7e6cd32b34046,2
+np.float64,0xbfc7cbeccf2f97d8,0xbfc8139a2626edae,2
+np.float64,0x3fbf31e4fa3e63d0,0x3fbf59c6e863255e,2
+np.float64,0x3fdf03fa05be07f4,0x3fe0ed953f7989ad,2
+np.float64,0x3fe7f4eaceefe9d6,0x3fef092ca7e2ac39,2
+np.float64,0xbfc084e9d92109d4,0xbfc09ca10fd6aaea,2
+np.float64,0xbf88cfbf70319f80,0xbf88d00effa6d897,2
+np.float64,0x7ff4000000000000,0x7ffc000000000000,2
+np.float64,0xbfa0176e9c202ee0,0xbfa018ca0a6ceef3,2
+np.float64,0xbfd88d0815b11a10,0xbfd9dfc6c6bcbe4e,2
+np.float64,0x3fe89f7730713eee,0x3ff04de52fb536f3,2
+np.float64,0xbfedc9707bfb92e1,0xbffaa25fcf9dd6da,2
+np.float64,0x3fe936d1a6726da4,0x3ff10e40c2d94bc9,2
+np.float64,0x3fdb64aec7b6c95c,0x3fdd473177317b3f,2
+np.float64,0xbfee4f9aaefc9f35,0xbffcdd212667003c,2
+np.float64,0x3fe3730067e6e600,0x3fe692b0a0babf5f,2
+np.float64,0xbfc257e58924afcc,0xbfc27871f8c218d7,2
+np.float64,0x3fe62db12dec5b62,0x3feb52c61b97d9f6,2
+np.float64,0xbfe3ff491367fe92,0xbfe774f1b3a96fd6,2
+np.float64,0x3fea43255274864a,0x3ff28b0c4b7b8d21,2
+np.float64,0xbfea37923c746f24,0xbff27962159f2072,2
+np.float64,0x3fcd0ac3c73a1588,0x3fcd8e6f8de41755,2
+np.float64,0xbfdccafde6b995fc,0xbfdf030fea8a0630,2
+np.float64,0x3fdba35268b746a4,0x3fdd94094f6f50c1,2
+np.float64,0x3fc68ea1d92d1d40,0x3fc6cb8d07cbb0e4,2
+np.float64,0xbfb88b1f6e311640,0xbfb89e7af4e58778,2
+np.float64,0xbfedc7cadffb8f96,0xbffa9c3766227956,2
+np.float64,0x3fe7928d3eef251a,0x3fee2dcf2ac7961b,2
+np.float64,0xbfeff42ede7fe85e,0xc00cef6b0f1e8323,2
+np.float64,0xbfebf07fa477e0ff,0xbff5893f99e15236,2
+np.float64,0x3fe3002ab9660056,0x3fe5defba550c583,2
+np.float64,0x3feb8f4307f71e86,0x3ff4c517ec8d6de9,2
+np.float64,0x3fd3c16f49a782e0,0x3fd46becaacf74da,2
+np.float64,0x3fc7613df12ec278,0x3fc7a52b2a3c3368,2
+np.float64,0xbfe33af560e675eb,0xbfe63a6528ff1587,2
+np.float64,0xbfde86495abd0c92,0xbfe09bd7ba05b461,2
+np.float64,0x3fe1e7fb4ee3cff6,0x3fe43b04311c0ab6,2
+np.float64,0xbfc528b6bd2a516c,0xbfc55ae0a0c184c8,2
+np.float64,0xbfd81025beb0204c,0xbfd94dd72d804613,2
+np.float64,0x10000000000000,0x10000000000000,2
+np.float64,0x3fc1151c47222a38,0x3fc12f5aad80a6bf,2
+np.float64,0x3feafa136775f426,0x3ff3b46854da0b3a,2
+np.float64,0x3fed2da0747a5b40,0x3ff89c85b658459e,2
+np.float64,0x3fda2a4b51b45498,0x3fdbca0d908ddbbd,2
+np.float64,0xbfd04cf518a099ea,0xbfd0aae0033b9e4c,2
+np.float64,0xbfb9065586320ca8,0xbfb91adb7e31f322,2
+np.float64,0xbfd830b428b06168,0xbfd973ca3c484d8d,2
+np.float64,0x3fc952f7ed32a5f0,0x3fc9a9994561fc1a,2
+np.float64,0xbfeb06c83c760d90,0xbff3ca77b326df20,2
+np.float64,0xbfeb1c98ac763931,0xbff3f0d0900f6149,2
+np.float64,0x3fdf061dbebe0c3c,0x3fe0eefb32b48d17,2
+np.float64,0xbf9acbaf28359760,0xbf9acd4024be9fec,2
+np.float64,0x3fec0adde2f815bc,0x3ff5c1628423794d,2
+np.float64,0xbfc4bc750d2978ec,0xbfc4eba43f590b94,2
+np.float64,0x3fdbe47878b7c8f0,0x3fdde44a2b500d73,2
+np.float64,0x3fe160d18162c1a4,0x3fe378cff08f18f0,2
+np.float64,0x3fc3b58dfd276b18,0x3fc3de01d3802de9,2
+np.float64,0x3fa860343430c060,0x3fa864ecd07ec962,2
+np.float64,0x3fcaebfb4b35d7f8,0x3fcb546512d1b4c7,2
+np.float64,0x3fe3fda558e7fb4a,0x3fe772412e5776de,2
+np.float64,0xbfe8169f2c702d3e,0xbfef5666c9a10f6d,2
+np.float64,0x3feda78e9efb4f1e,0x3ffa270712ded769,2
+np.float64,0xbfda483161b49062,0xbfdbedfbf2e850ba,2
+np.float64,0x3fd7407cf3ae80f8,0x3fd85d4f52622743,2
+np.float64,0xbfd63de4d4ac7bca,0xbfd73550a33e3c32,2
+np.float64,0xbfd9c30b90b38618,0xbfdb4e7695c856f3,2
+np.float64,0x3fcd70c00b3ae180,0x3fcdfa0969e0a119,2
+np.float64,0x3feb4f127f769e24,0x3ff44bf42514e0f4,2
+np.float64,0xbfec1db44af83b69,0xbff5ea54aed1f8e9,2
+np.float64,0x3fd68ff051ad1fe0,0x3fd792d0ed6d6122,2
+np.float64,0x3fe0a048a5614092,0x3fe26c80a826b2a2,2
+np.float64,0x3fd59f3742ab3e70,0x3fd6818563fcaf80,2
+np.float64,0x3fca26ecf9344dd8,0x3fca867ceb5d7ba8,2
+np.float64,0x3fdc1d547ab83aa8,0x3fde2a9cea866484,2
+np.float64,0xbfc78df6312f1bec,0xbfc7d3719b698a39,2
+np.float64,0x3fe754e72b6ea9ce,0x3feda89ea844a2e5,2
+np.float64,0x3fe740c1a4ee8184,0x3fed7dc56ec0c425,2
+np.float64,0x3fe77566a9eeeace,0x3fedee6f408df6de,2
+np.float64,0xbfbbf5bf8e37eb80,0xbfbc126a223781b4,2
+np.float64,0xbfe0acb297615965,0xbfe27d86681ca2b5,2
+np.float64,0xbfc20a0487241408,0xbfc228f5f7d52ce8,2
+np.float64,0xfff0000000000000,0xfff8000000000000,2
+np.float64,0x3fef98a4dbff314a,0x40043cfb60bd46fa,2
+np.float64,0x3fd059102ca0b220,0x3fd0b7d2be6d7822,2
+np.float64,0x3fe89f18a1f13e32,0x3ff04d714bbbf400,2
+np.float64,0x3fd45b6275a8b6c4,0x3fd516a44a276a4b,2
+np.float64,0xbfe04463e86088c8,0xbfe1ef9dfc9f9a53,2
+np.float64,0xbfe086e279610dc5,0xbfe249c9c1040a13,2
+np.float64,0x3f89c9b110339380,0x3f89ca0a641454b5,2
+np.float64,0xbfb5f5b4322beb68,0xbfb6038dc3fd1516,2
+np.float64,0x3fe6eae76f6dd5ce,0x3feccabae04d5c14,2
+np.float64,0x3fa9ef6c9c33dee0,0x3fa9f51c9a8c8a2f,2
+np.float64,0xbfe171b45f62e368,0xbfe390ccc4c01bf6,2
+np.float64,0x3fb2999442253330,0x3fb2a1fc006804b5,2
+np.float64,0x3fd124bf04a24980,0x3fd1927abb92472d,2
+np.float64,0xbfe6e05938edc0b2,0xbfecb519ba78114f,2
+np.float64,0x3fed466ee6fa8cde,0x3ff8e75405b50490,2
+np.float64,0xbfb999aa92333358,0xbfb9afa4f19f80a2,2
+np.float64,0xbfe98969ed7312d4,0xbff17d887b0303e7,2
+np.float64,0x3fe782843e6f0508,0x3fee0adbeebe3486,2
+np.float64,0xbfe232fcc26465fa,0xbfe4a90a68d46040,2
+np.float64,0x3fd190a90fa32154,0x3fd206f56ffcdca2,2
+np.float64,0xbfc4f8b75929f170,0xbfc5298b2d4e7740,2
+np.float64,0xbfba3a63d63474c8,0xbfba520835c2fdc2,2
+np.float64,0xbfb7708eea2ee120,0xbfb781695ec17846,2
+np.float64,0x3fed9fb7a5fb3f70,0x3ffa0b717bcd1609,2
+np.float64,0xbfc1b158cd2362b0,0xbfc1ce87345f3473,2
+np.float64,0x3f963478082c6900,0x3f96355c3000953b,2
+np.float64,0x3fc5050e532a0a20,0x3fc536397f38f616,2
+np.float64,0x3fe239f9eee473f4,0x3fe4b360da3b2faa,2
+np.float64,0xbfd66bd80eacd7b0,0xbfd769a29fd784c0,2
+np.float64,0x3fc57cdad52af9b8,0x3fc5b16b937f5f72,2
+np.float64,0xbfd3c36a0aa786d4,0xbfd46e1cd0b4eddc,2
+np.float64,0x3feff433487fe866,0x400cf0ea1def3161,2
+np.float64,0xbfed5577807aaaef,0xbff915e8f6bfdf22,2
+np.float64,0xbfca0dd3eb341ba8,0xbfca6c4d11836cb6,2
+np.float64,0x7ff8000000000000,0x7ff8000000000000,2
+np.float64,0xbf974deaa82e9be0,0xbf974ef26a3130d1,2
+np.float64,0xbfe7f425e1efe84c,0xbfef076cb00d649d,2
+np.float64,0xbfe4413605e8826c,0xbfe7e20448b8a4b1,2
+np.float64,0xbfdfad202cbf5a40,0xbfe15cd9eb2be707,2
+np.float64,0xbfe43261ee6864c4,0xbfe7c952c951fe33,2
+np.float64,0xbfec141225782824,0xbff5d54d33861d98,2
+np.float64,0x3fd0f47abaa1e8f4,0x3fd15e8691a7f1c2,2
+np.float64,0x3fd378f0baa6f1e0,0x3fd41bea4a599081,2
+np.float64,0xbfb52523462a4a48,0xbfb5317fa7f436e2,2
+np.float64,0x3fcb30797d3660f0,0x3fcb9c174ea401ff,2
+np.float64,0xbfd48480dea90902,0xbfd5446e02c8b329,2
+np.float64,0xbfee4ae3ab7c95c7,0xbffcc650340ba274,2
+np.float64,0xbfeab086d075610e,0xbff3387f4e83ae26,2
+np.float64,0x3fa17cddf422f9c0,0x3fa17e9bf1b25736,2
+np.float64,0xbfe3064536e60c8a,0xbfe5e86aa5244319,2
+np.float64,0x3feb2882c5765106,0x3ff40604c7d97d44,2
+np.float64,0xbfa6923ff42d2480,0xbfa695ff57b2fc3f,2
+np.float64,0xbfa8bdbdcc317b80,0xbfa8c2ada0d94aa7,2
+np.float64,0x3fe7f16b8e6fe2d8,0x3fef013948c391a6,2
+np.float64,0x3fe4e7169f69ce2e,0x3fe8fceef835050a,2
+np.float64,0x3fed877638fb0eec,0x3ff9b83694127959,2
+np.float64,0xbfe0cc9ecf61993e,0xbfe2a978234cbde5,2
+np.float64,0xbfe977e79672efcf,0xbff16589ea494a38,2
+np.float64,0xbfe240130ae48026,0xbfe4bc69113e0d7f,2
+np.float64,0x3feb1e9b70763d36,0x3ff3f4615938a491,2
+np.float64,0xbfdf197dfcbe32fc,0xbfe0fba78a0fc816,2
+np.float64,0xbfee0f8543fc1f0a,0xbffbb9d9a4ee5387,2
+np.float64,0x3fe88d2191f11a44,0x3ff037843b5b6313,2
+np.float64,0xbfd11bb850a23770,0xbfd188c1cef40007,2
+np.float64,0xbfa1b36e9c2366e0,0xbfa1b53d1d8a8bc4,2
+np.float64,0xbfea2d70d9f45ae2,0xbff26a0629e36b3e,2
+np.float64,0xbfd9188703b2310e,0xbfda83f9ddc18348,2
+np.float64,0xbfee194894fc3291,0xbffbe3c83b61e7cb,2
+np.float64,0xbfe093b4a9e1276a,0xbfe25b4ad6f8f83d,2
+np.float64,0x3fea031489f4062a,0x3ff22accc000082e,2
+np.float64,0xbfc6c0827b2d8104,0xbfc6ff0a94326381,2
+np.float64,0x3fef5cd340feb9a6,0x4002659c5a1b34af,2
+np.float64,0x8010000000000000,0x8010000000000000,2
+np.float64,0x3fd97cb533b2f96c,0x3fdafab28aaae8e3,2
+np.float64,0x3fe2123334642466,0x3fe478bd83a8ce02,2
+np.float64,0xbfd9a69637b34d2c,0xbfdb2c87c6b6fb8c,2
+np.float64,0x3fc58def7f2b1be0,0x3fc5c2ff724a9f61,2
+np.float64,0xbfedd5da1f7babb4,0xbffad15949b7fb22,2
+np.float64,0x3fe90e92a0721d26,0x3ff0d9b64323efb8,2
+np.float64,0x3fd34b9442a69728,0x3fd3e9f8fe80654e,2
+np.float64,0xbfc5f509ab2bea14,0xbfc62d2ad325c59f,2
+np.float64,0x3feb245634f648ac,0x3ff3fe91a46acbe1,2
+np.float64,0x3fd101e539a203cc,0x3fd16cf52ae6d203,2
+np.float64,0xbfc51e9ba72a3d38,0xbfc5507d00521ba3,2
+np.float64,0x3fe5fe1683ebfc2e,0x3feaf7dd8b1f92b0,2
+np.float64,0x3fc362e59126c5c8,0x3fc389601814170b,2
+np.float64,0x3fea34dbd77469b8,0x3ff27542eb721e7e,2
+np.float64,0xbfc13ed241227da4,0xbfc159d42c0a35a9,2
+np.float64,0xbfe6df118cedbe23,0xbfecb27bb5d3f784,2
+np.float64,0x3fd92895f6b2512c,0x3fda96f5f94b625e,2
+np.float64,0xbfe7ea3aa76fd476,0xbfeef0e93939086e,2
+np.float64,0xbfc855498330aa94,0xbfc8a1ff690c9533,2
+np.float64,0x3fd9f27b3ab3e4f8,0x3fdb8726979afc3b,2
+np.float64,0x3fc65d52232cbaa8,0x3fc698ac4367afba,2
+np.float64,0x3fd1271dd0a24e3c,0x3fd195087649d54e,2
+np.float64,0xbfe983445df30689,0xbff175158b773b90,2
+np.float64,0xbfe0d9b13261b362,0xbfe2bb8908fc9e6e,2
+np.float64,0x3fd7671f2aaece40,0x3fd889dccbf21629,2
+np.float64,0x3fe748aebfee915e,0x3fed8e970d94c17d,2
+np.float64,0x3fea756e4e74eadc,0x3ff2d947ef3a54f4,2
+np.float64,0x3fde22311cbc4464,0x3fe05b4ce9df1fdd,2
+np.float64,0x3fe2b55ec1e56abe,0x3fe56c6849e3985a,2
+np.float64,0x3fed7b47437af68e,0x3ff98f8e82de99a0,2
+np.float64,0x3fec8184b179030a,0x3ff6d03aaf0135ba,2
+np.float64,0x3fc9ea825533d508,0x3fca4776d7190e71,2
+np.float64,0xbfe8ddd58b71bbab,0xbff09b770ed7bc9a,2
+np.float64,0xbfed41741bfa82e8,0xbff8d81c2a9fc615,2
+np.float64,0x3fe0a73888e14e72,0x3fe27602ad9a3726,2
+np.float64,0xbfe9d0a565f3a14b,0xbff1e1897b628f66,2
+np.float64,0x3fda12b381b42568,0x3fdbadbec22fbd5a,2
+np.float64,0x3fef0081187e0102,0x4000949eff8313c2,2
+np.float64,0x3fef6942b67ed286,0x4002b7913eb1ee76,2
+np.float64,0x3fda10f882b421f0,0x3fdbababa2d6659d,2
+np.float64,0x3fe5828971eb0512,0x3fea122b5088315a,2
+np.float64,0x3fe9d4b53ff3a96a,0x3ff1e75c148bda01,2
+np.float64,0x3fe95d246bf2ba48,0x3ff1414a61a136ec,2
+np.float64,0x3f9e575eb83caec0,0x3f9e59a4f17179e3,2
+np.float64,0x3fdb0a20b5b61440,0x3fdcd8a56178a17f,2
+np.float64,0xbfdef425e3bde84c,0xbfe0e33eeacf3861,2
+np.float64,0x3fd6afcf6bad5fa0,0x3fd7b73d47288347,2
+np.float64,0x3fe89256367124ac,0x3ff03dd9f36ce40e,2
+np.float64,0x3fe7e560fcefcac2,0x3feee5ef8688b60b,2
+np.float64,0x3fedef55e1fbdeac,0x3ffb350ee1df986b,2
+np.float64,0xbfe44b926de89725,0xbfe7f3539910c41f,2
+np.float64,0x3fc58310f32b0620,0x3fc5b7cfdba15bd0,2
+np.float64,0x3f736d256026da00,0x3f736d2eebe91a90,2
+np.float64,0x3feb012d2076025a,0x3ff3c0b5d21a7259,2
+np.float64,0xbfe466a6c468cd4e,0xbfe820c9c197601f,2
+np.float64,0x3fe1aba8aa635752,0x3fe3e3b73920f64c,2
+np.float64,0x3fe5597c336ab2f8,0x3fe9c7bc4b765b15,2
+np.float64,0x3fe1004ac5e20096,0x3fe2f12116e99821,2
+np.float64,0x3fecbc67477978ce,0x3ff76377434dbdad,2
+np.float64,0x3fe0e64515e1cc8a,0x3fe2ccf5447c1579,2
+np.float64,0x3febcfa874f79f50,0x3ff54528f0822144,2
+np.float64,0x3fc36915ed26d228,0x3fc38fb5b28d3f72,2
+np.float64,0xbfe01213e5e02428,0xbfe1ac0e1e7418f1,2
+np.float64,0x3fcd97875b3b2f10,0x3fce22fe3fc98702,2
+np.float64,0xbfe30383c5e60708,0xbfe5e427e62cc957,2
+np.float64,0xbfde339bf9bc6738,0xbfe0667f337924f5,2
+np.float64,0xbfda7c1c49b4f838,0xbfdc2c8801ce654a,2
+np.float64,0x3fb6b3489e2d6690,0x3fb6c29650387b92,2
+np.float64,0xbfe1fd4d76e3fa9b,0xbfe45a1f60077678,2
+np.float64,0xbf67c5e0402f8c00,0xbf67c5e49fce115a,2
+np.float64,0xbfd4f9aa2da9f354,0xbfd5c759603d0b9b,2
+np.float64,0x3fe83c227bf07844,0x3fefada9f1bd7fa9,2
+np.float64,0xbf97f717982fee20,0xbf97f836701a8cd5,2
+np.float64,0x3fe9688a2472d114,0x3ff150aa575e7d51,2
+np.float64,0xbfc5a9779d2b52f0,0xbfc5df56509c48b1,2
+np.float64,0xbfe958d5f472b1ac,0xbff13b813f9bee20,2
+np.float64,0xbfd7b3b944af6772,0xbfd8e276c2b2920f,2
+np.float64,0x3fed10198e7a2034,0x3ff8469c817572f0,2
+np.float64,0xbfeeecc4517dd989,0xc000472b1f858be3,2
+np.float64,0xbfdbcce47eb799c8,0xbfddc734aa67812b,2
+np.float64,0xbfd013ee24a027dc,0xbfd06df3089384ca,2
+np.float64,0xbfd215f2bfa42be6,0xbfd29774ffe26a74,2
+np.float64,0x3fdfd0ae67bfa15c,0x3fe1746e3a963a9f,2
+np.float64,0xbfc84aa10b309544,0xbfc896f0d25b723a,2
+np.float64,0xbfcd0c627d3a18c4,0xbfcd9024c73747a9,2
+np.float64,0x3fd87df6dbb0fbec,0x3fd9ce1dde757f31,2
+np.float64,0xbfdad85e05b5b0bc,0xbfdc9c2addb6ce47,2
+np.float64,0xbfee4f8977fc9f13,0xbffcdccd68e514b3,2
+np.float64,0x3fa5c290542b8520,0x3fa5c5ebdf09ca70,2
+np.float64,0xbfd7e401d2afc804,0xbfd91a7e4eb5a026,2
+np.float64,0xbfe33ff73b667fee,0xbfe6423cc6eb07d7,2
+np.float64,0x3fdfb7d6c4bf6fac,0x3fe163f2e8175177,2
+np.float64,0xbfd515d69eaa2bae,0xbfd5e6eedd6a1598,2
+np.float64,0x3fb322232e264440,0x3fb32b49d91c3cbe,2
+np.float64,0xbfe20ac39e641587,0xbfe46dd4b3803f19,2
+np.float64,0x3fe282dc18e505b8,0x3fe520152120c297,2
+np.float64,0xbfc905a4cd320b48,0xbfc95929b74865fb,2
+np.float64,0x3fe0ae3b83615c78,0x3fe27fa1dafc825b,2
+np.float64,0xbfc1bfed0f237fdc,0xbfc1dd6466225cdf,2
+np.float64,0xbfeca4d47d7949a9,0xbff72761a34fb682,2
+np.float64,0xbfe8cf8c48f19f18,0xbff0897ebc003626,2
+np.float64,0xbfe1aaf0a36355e2,0xbfe3e2ae7b17a286,2
+np.float64,0x3fe2ca442e659488,0x3fe58c3a2fb4f14a,2
+np.float64,0xbfda3c2deeb4785c,0xbfdbdf89fe96a243,2
+np.float64,0xbfdc12bfecb82580,0xbfde1d81dea3c221,2
+np.float64,0xbfe2d6d877e5adb1,0xbfe59f73e22c1fc7,2
+np.float64,0x3fe5f930636bf260,0x3feaee96a462e4de,2
+np.float64,0x3fcf3c0ea53e7820,0x3fcfe0b0f92be7e9,2
+np.float64,0xbfa5bb90f42b7720,0xbfa5bee9424004cc,2
+np.float64,0xbfe2fb3a3265f674,0xbfe5d75b988bb279,2
+np.float64,0x3fcaec7aab35d8f8,0x3fcb54ea582fff6f,2
+np.float64,0xbfd8d3228db1a646,0xbfda322297747fbc,2
+np.float64,0x3fedd2e0ad7ba5c2,0x3ffac6002b65c424,2
+np.float64,0xbfd9edeca2b3dbda,0xbfdb81b2b7785e33,2
+np.float64,0xbfef5febb17ebfd7,0xc002796b15950960,2
+np.float64,0x3fde22f787bc45f0,0x3fe05bcc624b9ba2,2
+np.float64,0xbfc716a4ab2e2d48,0xbfc758073839dd44,2
+np.float64,0xbf9bed852837db00,0xbf9bef4b2a3f3bdc,2
+np.float64,0x3fef8f88507f1f10,0x4003e5e566444571,2
+np.float64,0xbfdc1bbed6b8377e,0xbfde28a64e174e60,2
+np.float64,0x3fe02d30eae05a62,0x3fe1d064ec027cd3,2
+np.float64,0x3fd9dbb500b3b76c,0x3fdb6bea40162279,2
+np.float64,0x3fe353ff1d66a7fe,0x3fe661b3358c925e,2
+np.float64,0x3fac3ebfb4387d80,0x3fac4618effff2b0,2
+np.float64,0x3fe63cf0ba6c79e2,0x3feb7030cff5f434,2
+np.float64,0x3fd0e915f8a1d22c,0x3fd152464597b510,2
+np.float64,0xbfd36987cda6d310,0xbfd40af049d7621e,2
+np.float64,0xbfdc5b4dc7b8b69c,0xbfde7790a35da2bc,2
+np.float64,0x3feee7ff4a7dcffe,0x40003545989e07c7,2
+np.float64,0xbfeb2c8308765906,0xbff40d2e6469249e,2
+np.float64,0x3fe535a894ea6b52,0x3fe98781648550d0,2
+np.float64,0xbfef168eb9fe2d1d,0xc000f274ed3cd312,2
+np.float64,0x3fc3e2d98927c5b0,0x3fc40c6991b8900c,2
+np.float64,0xbfcd8fe3e73b1fc8,0xbfce1aec7f9b7f7d,2
+np.float64,0xbfd55d8c3aaabb18,0xbfd6378132ee4892,2
+np.float64,0xbfe424a66168494d,0xbfe7b289d72c98b3,2
+np.float64,0x3fd81af13eb035e4,0x3fd95a6a9696ab45,2
+np.float64,0xbfe3016722e602ce,0xbfe5e0e46db228cd,2
+np.float64,0x3fe9a20beff34418,0x3ff19faca17fc468,2
+np.float64,0xbfe2124bc7e42498,0xbfe478e19927e723,2
+np.float64,0x3fd96f8622b2df0c,0x3fdaeb08da6b08ae,2
+np.float64,0x3fecd6796579acf2,0x3ff7a7d02159e181,2
+np.float64,0x3fe60015df6c002c,0x3feafba6f2682a61,2
+np.float64,0x3fc7181cf72e3038,0x3fc7598c2cc3c3b4,2
+np.float64,0xbfce6e2e0b3cdc5c,0xbfcf0621b3e37115,2
+np.float64,0xbfe52a829e6a5505,0xbfe973a785980af9,2
+np.float64,0x3fed4bbac37a9776,0x3ff8f7a0e68a2bbe,2
+np.float64,0x3fabdfaacc37bf60,0x3fabe6bab42bd246,2
+np.float64,0xbfcd9598cb3b2b30,0xbfce20f3c4c2c261,2
+np.float64,0x3fd717d859ae2fb0,0x3fd82e88eca09ab1,2
+np.float64,0x3fe28ccb18e51996,0x3fe52f071d2694fd,2
+np.float64,0xbfe43f064ae87e0c,0xbfe7de5eab36b5b9,2
+np.float64,0x7fefffffffffffff,0xfff8000000000000,2
+np.float64,0xbfb39b045a273608,0xbfb3a4dd3395fdd5,2
+np.float64,0xbfb3358bae266b18,0xbfb33ece5e95970a,2
+np.float64,0xbfeeafb6717d5f6d,0xbffeec3f9695b575,2
+np.float64,0xbfe7a321afef4644,0xbfee522dd80f41f4,2
+np.float64,0x3fe3a17e5be742fc,0x3fe6dcd32af51e92,2
+np.float64,0xbfc61694bd2c2d28,0xbfc64fbbd835f6e7,2
+np.float64,0xbfd795906faf2b20,0xbfd8bf89b370655c,2
+np.float64,0xbfe4b39b59e96736,0xbfe8a3c5c645b6e3,2
+np.float64,0x3fd310af3ba62160,0x3fd3a9442e825e1c,2
+np.float64,0xbfd45198a6a8a332,0xbfd50bc10311a0a3,2
+np.float64,0x3fd0017eaaa002fc,0x3fd05a472a837999,2
+np.float64,0xbfea974d98752e9b,0xbff30f67f1835183,2
+np.float64,0xbf978f60582f1ec0,0xbf979070e1c2b59d,2
+np.float64,0x3fe1c715d4e38e2c,0x3fe40b479e1241a2,2
+np.float64,0xbfccb965cd3972cc,0xbfcd38b40c4a352d,2
+np.float64,0xbfd9897048b312e0,0xbfdb09d55624c2a3,2
+np.float64,0x3fe7f5de4befebbc,0x3fef0b56be259f9c,2
+np.float64,0x3fcc6c6d4338d8d8,0x3fcce7b20ed68a78,2
+np.float64,0xbfe63884046c7108,0xbfeb67a3b945c3ee,2
+np.float64,0xbfce64e2ad3cc9c4,0xbfcefc47fae2e81f,2
+np.float64,0x3fefeb57b27fd6b0,0x400ab2eac6321cfb,2
+np.float64,0x3fe679627e6cf2c4,0x3febe6451b6ee0c4,2
+np.float64,0x3fc5f710172bee20,0x3fc62f40f85cb040,2
+np.float64,0x3fc34975e52692e8,0x3fc36f58588c7fa2,2
+np.float64,0x3fe8a3784cf146f0,0x3ff052ced9bb9406,2
+np.float64,0x3fd11a607ca234c0,0x3fd1874f876233fe,2
+np.float64,0x3fb2d653f625aca0,0x3fb2df0f4c9633f3,2
+np.float64,0x3fe555f39eeaabe8,0x3fe9c15ee962a28c,2
+np.float64,0xbfea297e3bf452fc,0xbff264107117f709,2
+np.float64,0x3fe1581cdde2b03a,0x3fe36c79acedf99c,2
+np.float64,0x3fd4567063a8ace0,0x3fd51123dbd9106f,2
+np.float64,0x3fa3883aec271080,0x3fa38aa86ec71218,2
+np.float64,0x3fe40e5d7de81cba,0x3fe78dbb9b568850,2
+np.float64,0xbfe9a2f7347345ee,0xbff1a0f4faa05041,2
+np.float64,0x3f9eef03a83dde00,0x3f9ef16caa0c1478,2
+np.float64,0xbfcb4641d1368c84,0xbfcbb2e7ff8c266d,2
+np.float64,0xbfa8403b2c308070,0xbfa844e148b735b7,2
+np.float64,0xbfe1875cd6e30eba,0xbfe3afadc08369f5,2
+np.float64,0xbfdd3c3d26ba787a,0xbfdf919b3e296766,2
+np.float64,0x3fcd6c4c853ad898,0x3fcdf55647b518b8,2
+np.float64,0xbfe360a173e6c143,0xbfe6759eb3a08cf2,2
+np.float64,0x3fe5a13147eb4262,0x3fea4a5a060f5adb,2
+np.float64,0x3feb3cdd7af679ba,0x3ff42aae0cf61234,2
+np.float64,0x3fe5205128ea40a2,0x3fe9618f3d0c54af,2
+np.float64,0x3fce35343f3c6a68,0x3fcec9c4e612b050,2
+np.float64,0xbfc345724d268ae4,0xbfc36b3ce6338e6a,2
+np.float64,0x3fedc4fc0e7b89f8,0x3ffa91c1d775c1f7,2
+np.float64,0x3fe41fbf21683f7e,0x3fe7aa6c174a0e65,2
+np.float64,0xbfc7a1a5d32f434c,0xbfc7e7d27a4c5241,2
+np.float64,0x3fd3e33eaca7c67c,0x3fd4915264441e2f,2
+np.float64,0x3feb3f02f6f67e06,0x3ff42e942249e596,2
+np.float64,0x3fdb75fcb0b6ebf8,0x3fdd5c63f98b6275,2
+np.float64,0x3fd6476603ac8ecc,0x3fd74020b164cf38,2
+np.float64,0x3fed535372faa6a6,0x3ff90f3791821841,2
+np.float64,0x3fe8648ead70c91e,0x3ff006a62befd7ed,2
+np.float64,0x3fd0f90760a1f210,0x3fd1636b39bb1525,2
+np.float64,0xbfca052443340a48,0xbfca633d6e777ae0,2
+np.float64,0xbfa6a5e3342d4bc0,0xbfa6a9ac6a488f5f,2
+np.float64,0x3fd5598038aab300,0x3fd632f35c0c3d52,2
+np.float64,0xbfdf66218fbecc44,0xbfe12df83b19f300,2
+np.float64,0x3fe78e15b56f1c2c,0x3fee240d12489cd1,2
+np.float64,0x3fe3d6a7b3e7ad50,0x3fe7329dcf7401e2,2
+np.float64,0xbfddb8e97bbb71d2,0xbfe017ed6d55a673,2
+np.float64,0xbfd57afd55aaf5fa,0xbfd658a9607c3370,2
+np.float64,0xbfdba4c9abb74994,0xbfdd95d69e5e8814,2
+np.float64,0xbfe71d8090ee3b01,0xbfed3390be6d2eef,2
+np.float64,0xbfc738ac0f2e7158,0xbfc77b3553b7c026,2
+np.float64,0x3f873656302e6c80,0x3f873697556ae011,2
+np.float64,0x3fe559491d6ab292,0x3fe9c7603b12c608,2
+np.float64,0xbfe262776864c4ef,0xbfe4ef905dda8599,2
+np.float64,0x3fe59d8917eb3b12,0x3fea439f44b7573f,2
+np.float64,0xbfd4b5afb5a96b60,0xbfd57b4e3df4dbc8,2
+np.float64,0x3fe81158447022b0,0x3fef4a3cea3eb6a9,2
+np.float64,0xbfeb023441f60468,0xbff3c27f0fc1a4dc,2
+np.float64,0x3fefb212eaff6426,0x40055fc6d949cf44,2
+np.float64,0xbfe1300ac1e26016,0xbfe333f297a1260e,2
+np.float64,0xbfeae0a2f575c146,0xbff388d58c380b8c,2
+np.float64,0xbfeddd8e55fbbb1d,0xbffaef045b2e21d9,2
+np.float64,0x3fec7c6c1d78f8d8,0x3ff6c3ebb019a8e5,2
+np.float64,0xbfe27e071f64fc0e,0xbfe518d2ff630f33,2
+np.float64,0x8000000000000001,0x8000000000000001,2
+np.float64,0x3fc5872abf2b0e58,0x3fc5bc083105db76,2
+np.float64,0x3fe65114baeca22a,0x3feb9745b82ef15a,2
+np.float64,0xbfc783abe52f0758,0xbfc7c8cb23f93e79,2
+np.float64,0x3fe4b7a5dd696f4c,0x3fe8aab9d492f0ca,2
+np.float64,0xbf91a8e8a82351e0,0xbf91a95b6ae806f1,2
+np.float64,0xbfee482eb77c905d,0xbffcb952830e715a,2
+np.float64,0x3fba0eee2a341de0,0x3fba261d495e3a1b,2
+np.float64,0xbfeb8876ae7710ed,0xbff4b7f7f4343506,2
+np.float64,0xbfe4d29e46e9a53c,0xbfe8d9547a601ba7,2
+np.float64,0xbfe12413b8e24828,0xbfe3232656541d10,2
+np.float64,0x3fc0bd8f61217b20,0x3fc0d63f937f0aa4,2
+np.float64,0xbfd3debafda7bd76,0xbfd48c534e5329e4,2
+np.float64,0x3fc0f92de921f258,0x3fc112eb7d47349b,2
+np.float64,0xbfe576b95f6aed72,0xbfe9fca859239b3c,2
+np.float64,0x3fd10e520da21ca4,0x3fd17a546e4152f7,2
+np.float64,0x3fcef917eb3df230,0x3fcf998677a8fa8f,2
+np.float64,0x3fdfcf863abf9f0c,0x3fe173a98af1cb13,2
+np.float64,0x3fc28c4b4f251898,0x3fc2adf43792e917,2
+np.float64,0x3fceb837ad3d7070,0x3fcf54a63b7d8c5c,2
+np.float64,0x3fc0140a05202818,0x3fc029e4f75330cb,2
+np.float64,0xbfd76c3362aed866,0xbfd88fb9e790b4e8,2
+np.float64,0xbfe475300868ea60,0xbfe8395334623e1f,2
+np.float64,0x3fea70b9b4f4e174,0x3ff2d1dad92173ba,2
+np.float64,0xbfe2edbd4965db7a,0xbfe5c29449a9365d,2
+np.float64,0xbfddf86f66bbf0de,0xbfe0408439cada9b,2
+np.float64,0xbfb443cdfa288798,0xbfb44eae796ad3ea,2
+np.float64,0xbf96a8a0482d5140,0xbf96a992b6ef073b,2
+np.float64,0xbfd279db2fa4f3b6,0xbfd3043db6acbd9e,2
+np.float64,0x3fe5d99088ebb322,0x3feab30be14e1605,2
+np.float64,0xbfe1a917abe35230,0xbfe3e0063d0f5f63,2
+np.float64,0x3fc77272f52ee4e8,0x3fc7b6f8ab6f4591,2
+np.float64,0x3fd6b62146ad6c44,0x3fd7be77eef8390a,2
+np.float64,0xbfe39fd9bc673fb4,0xbfe6da30dc4eadde,2
+np.float64,0x3fe35545c066aa8c,0x3fe663b5873e4d4b,2
+np.float64,0xbfcbbeffb3377e00,0xbfcc317edf7f6992,2
+np.float64,0xbfe28a58366514b0,0xbfe52b5734579ffa,2
+np.float64,0xbfbf0c87023e1910,0xbfbf33d970a0dfa5,2
+np.float64,0xbfd31144cba6228a,0xbfd3a9e84f9168f9,2
+np.float64,0xbfe5c044056b8088,0xbfea83d607c1a88a,2
+np.float64,0x3fdaabdf18b557c0,0x3fdc663ee8eddc83,2
+np.float64,0xbfeb883006f71060,0xbff4b76feff615be,2
+np.float64,0xbfebaef41d775de8,0xbff5034111440754,2
+np.float64,0x3fd9b6eb3bb36dd8,0x3fdb3fff5071dacf,2
+np.float64,0x3fe4e33c45e9c678,0x3fe8f637779ddedf,2
+np.float64,0x3fe52213a06a4428,0x3fe964adeff5c14e,2
+np.float64,0x3fe799254cef324a,0x3fee3c3ecfd3cdc5,2
+np.float64,0x3fd0533f35a0a680,0x3fd0b19a003469d3,2
+np.float64,0x3fec7ef5c7f8fdec,0x3ff6ca0abe055048,2
+np.float64,0xbfd1b5da82a36bb6,0xbfd22f357acbee79,2
+np.float64,0xbfd8f9c652b1f38c,0xbfda5faacbce9cf9,2
+np.float64,0x3fc8fc818b31f900,0x3fc94fa9a6aa53c8,2
+np.float64,0x3fcf42cc613e8598,0x3fcfe7dc128f33f2,2
+np.float64,0x3fd393a995a72754,0x3fd4396127b19305,2
+np.float64,0x3fec7b7df9f8f6fc,0x3ff6c1ae51753ef2,2
+np.float64,0x3fc07f175b20fe30,0x3fc096b55c11568c,2
+np.float64,0xbf979170082f22e0,0xbf979280d9555f44,2
+np.float64,0xbfb9d110c633a220,0xbfb9e79ba19b3c4a,2
+np.float64,0x3fedcd7d417b9afa,0x3ffab19734e86d58,2
+np.float64,0xbfec116f27f822de,0xbff5cf9425cb415b,2
+np.float64,0xbfec4fa0bef89f42,0xbff65a771982c920,2
+np.float64,0x3f94d4452829a880,0x3f94d501789ad11c,2
+np.float64,0xbfefe5ede27fcbdc,0xc009c440d3c2a4ce,2
+np.float64,0xbfe7e5f7b5efcbf0,0xbfeee74449aee1db,2
+np.float64,0xbfeb71dc8976e3b9,0xbff48cd84ea54ed2,2
+np.float64,0xbfe4cdb65f699b6c,0xbfe8d0d3bce901ef,2
+np.float64,0x3fb78ef1ee2f1de0,0x3fb7a00e7d183c48,2
+np.float64,0x3fb681864a2d0310,0x3fb6906fe64b4cd7,2
+np.float64,0xbfd2ad3b31a55a76,0xbfd33c57b5985399,2
+np.float64,0x3fdcdaaa95b9b554,0x3fdf16b99628db1e,2
+np.float64,0x3fa4780b7428f020,0x3fa47ad6ce9b8081,2
+np.float64,0x3fc546b0ad2a8d60,0x3fc579b361b3b18f,2
+np.float64,0x3feaf98dd6f5f31c,0x3ff3b38189c3539c,2
+np.float64,0x3feb0b2eca76165e,0x3ff3d22797083f9a,2
+np.float64,0xbfdc02ae3ab8055c,0xbfde099ecb5dbacf,2
+np.float64,0x3fd248bf17a49180,0x3fd2ceb77b346d1d,2
+np.float64,0x3fe349d666e693ac,0x3fe651b9933a8853,2
+np.float64,0xbfca526fc534a4e0,0xbfcab3e83f0d9b93,2
+np.float64,0x3fc156421722ac88,0x3fc171b38826563b,2
+np.float64,0xbfe4244569e8488b,0xbfe7b1e93e7d4f92,2
+np.float64,0x3fe010faabe021f6,0x3fe1aa961338886d,2
+np.float64,0xbfc52dacb72a5b58,0xbfc55ffa50eba380,2
+np.float64,0x8000000000000000,0x8000000000000000,2
+np.float64,0x3fea1d4865f43a90,0x3ff251b839eb4817,2
+np.float64,0xbfa0f65c8421ecc0,0xbfa0f7f37c91be01,2
+np.float64,0x3fcab29c0b356538,0x3fcb1863edbee184,2
+np.float64,0x3fe7949162ef2922,0x3fee323821958b88,2
+np.float64,0x3fdaf9288ab5f250,0x3fdcc400190a4839,2
+np.float64,0xbfe13ece6be27d9d,0xbfe348ba07553179,2
+np.float64,0x3f8a0c4fd0341880,0x3f8a0cabdf710185,2
+np.float64,0x3fdd0442a2ba0884,0x3fdf4b016c4da452,2
+np.float64,0xbfaf06d2343e0da0,0xbfaf1090b1600422,2
+np.float64,0xbfd3b65225a76ca4,0xbfd45fa49ae76cca,2
+np.float64,0x3fef5d75fefebaec,0x400269a5e7c11891,2
+np.float64,0xbfe048e35ce091c6,0xbfe1f5af45dd64f8,2
+np.float64,0xbfe27d4599e4fa8b,0xbfe517b07843d04c,2
+np.float64,0xbfe6f2a637ede54c,0xbfecdaa730462576,2
+np.float64,0x3fc63fbb752c7f78,0x3fc67a2854974109,2
+np.float64,0x3fedda6bfbfbb4d8,0x3ffae2e6131f3475,2
+np.float64,0x3fe7a6f5286f4dea,0x3fee5a9b1ef46016,2
+np.float64,0xbfd4ea8bcea9d518,0xbfd5b66ab7e5cf00,2
+np.float64,0x3fdc116568b822cc,0x3fde1bd4d0d9fd6c,2
+np.float64,0x3fdc45cb1bb88b98,0x3fde5cd1d2751032,2
+np.float64,0x3feabd932f757b26,0x3ff34e06e56a62a1,2
+np.float64,0xbfae5dbe0c3cbb80,0xbfae66e062ac0d65,2
+np.float64,0xbfdb385a00b670b4,0xbfdd10fedf3a58a7,2
+np.float64,0xbfebb14755f7628f,0xbff507e123a2b47c,2
+np.float64,0x3fe6de2fdfedbc60,0x3fecb0ae6e131da2,2
+np.float64,0xbfd86de640b0dbcc,0xbfd9bb4dbf0bf6af,2
+np.float64,0x3fe39e86d9e73d0e,0x3fe6d811c858d5d9,2
+np.float64,0x7ff0000000000000,0xfff8000000000000,2
+np.float64,0x3fa8101684302020,0x3fa814a12176e937,2
+np.float64,0x3fefdd5ad37fbab6,0x4008a08c0b76fbb5,2
+np.float64,0x3fe645c727ec8b8e,0x3feb814ebc470940,2
+np.float64,0x3fe3ba79dce774f4,0x3fe70500db564cb6,2
+np.float64,0xbfe0e5a254e1cb44,0xbfe2cc13940c6d9a,2
+np.float64,0x3fe2cac62465958c,0x3fe58d008c5e31f8,2
+np.float64,0xbfd3ffb531a7ff6a,0xbfd4b0d88cff2040,2
+np.float64,0x3fe0929104612522,0x3fe259bc42dce788,2
+np.float64,0x1,0x1,2
+np.float64,0xbfe7db77e6efb6f0,0xbfeecf93e8a61cb3,2
+np.float64,0xbfe37e9559e6fd2a,0xbfe6a514e29cb7aa,2
+np.float64,0xbfc53a843f2a7508,0xbfc56d2e9ad8b716,2
+np.float64,0xbfedb04485fb6089,0xbffa4615d4334ec3,2
+np.float64,0xbfc44349b1288694,0xbfc46f484b6f1cd6,2
+np.float64,0xbfe265188264ca31,0xbfe4f37d61cd9e17,2
+np.float64,0xbfd030351da0606a,0xbfd08c2537287ee1,2
+np.float64,0x3fd8fb131db1f628,0x3fda613363ca601e,2
+np.float64,0xbff0000000000000,0xfff0000000000000,2
+np.float64,0xbfe48d9a60691b35,0xbfe862c02d8fec1e,2
+np.float64,0x3fd185e050a30bc0,0x3fd1fb4c614ddb07,2
+np.float64,0xbfe4a5807e694b01,0xbfe88b8ff2d6caa7,2
+np.float64,0xbfc934d7ad3269b0,0xbfc98a405d25a666,2
+np.float64,0xbfea0e3c62741c79,0xbff23b4bd3a7b15d,2
+np.float64,0x3fe7244071ee4880,0x3fed41b27ba6bb22,2
+np.float64,0xbfd419f81ba833f0,0xbfd4cdf71b4533a3,2
+np.float64,0xbfe1e73a34e3ce74,0xbfe439eb15fa6baf,2
+np.float64,0x3fcdd9a63f3bb350,0x3fce68e1c401eff0,2
+np.float64,0x3fd1b5960ba36b2c,0x3fd22eeb566f1976,2
+np.float64,0x3fe9ad18e0735a32,0x3ff1af23c534260d,2
+np.float64,0xbfd537918aaa6f24,0xbfd60ccc8df0962b,2
+np.float64,0x3fcba3d3c73747a8,0x3fcc14fd5e5c49ad,2
+np.float64,0x3fd367e3c0a6cfc8,0x3fd40921b14e288e,2
+np.float64,0x3fe94303c6f28608,0x3ff11e62db2db6ac,2
+np.float64,0xbfcc5f77fd38bef0,0xbfccda110c087519,2
+np.float64,0xbfd63b74d7ac76ea,0xbfd7328af9f37402,2
+np.float64,0xbfe5321289ea6425,0xbfe9811ce96609ad,2
+np.float64,0xbfde910879bd2210,0xbfe0a2cd0ed1d368,2
+np.float64,0xbfcc9d9bad393b38,0xbfcd1b722a0b1371,2
+np.float64,0xbfe6dd39e16dba74,0xbfecaeb7c8c069f6,2
+np.float64,0xbfe98316eff3062e,0xbff174d7347d48bf,2
+np.float64,0xbfda88f8d1b511f2,0xbfdc3c0e75dad903,2
+np.float64,0x3fd400d8c2a801b0,0x3fd4b21bacff1f5d,2
+np.float64,0xbfe1ed335863da66,0xbfe4429e45e99779,2
+np.float64,0xbf3423a200284800,0xbf3423a20acb0342,2
+np.float64,0xbfe97bc59672f78b,0xbff16ad1adc44a33,2
+np.float64,0xbfeeca60d7fd94c2,0xbfff98d7f18f7728,2
+np.float64,0x3fd1eb13b2a3d628,0x3fd268e6ff4d56ce,2
+np.float64,0xbfa5594c242ab2a0,0xbfa55c77d6740a39,2
+np.float64,0x3fe72662006e4cc4,0x3fed462a9dedbfee,2
+np.float64,0x3fef4bb221fe9764,0x4001fe4f4cdfedb2,2
+np.float64,0xbfe938d417f271a8,0xbff110e78724ca2b,2
+np.float64,0xbfcc29ab2f385358,0xbfcca182140ef541,2
+np.float64,0x3fe18cd42c6319a8,0x3fe3b77e018165e7,2
+np.float64,0xbfec6c5cae78d8b9,0xbff69d8e01309b48,2
+np.float64,0xbfd5723da7aae47c,0xbfd64ecde17da471,2
+np.float64,0xbfe3096722e612ce,0xbfe5ed43634f37ff,2
+np.float64,0xbfdacaceb1b5959e,0xbfdc8bb826bbed39,2
+np.float64,0x3fc59a57cb2b34b0,0x3fc5cfc4a7c9bac8,2
+np.float64,0x3f84adce10295b80,0x3f84adfc1f1f6e97,2
+np.float64,0x3fdd5b28bbbab650,0x3fdfb8b906d77df4,2
+np.float64,0x3fdebf94c6bd7f28,0x3fe0c10188e1bc7c,2
+np.float64,0x3fdb30c612b6618c,0x3fdd07bf18597821,2
+np.float64,0x3fe7eeb3176fdd66,0x3feefb0be694b855,2
+np.float64,0x0,0x0,2
+np.float64,0xbfe10057e9e200b0,0xbfe2f13365e5b1c9,2
+np.float64,0xbfeb61a82376c350,0xbff46e665d3a60f5,2
+np.float64,0xbfe7f54aec6fea96,0xbfef0a0759f726dc,2
+np.float64,0xbfe4f6da3de9edb4,0xbfe9187d85bd1ab5,2
+np.float64,0xbfeb8be1b3f717c4,0xbff4be8efaab2e75,2
+np.float64,0x3fed40bc31fa8178,0x3ff8d5ec4a7f3e9b,2
+np.float64,0xbfe40f8711681f0e,0xbfe78fa5c62b191b,2
+np.float64,0x3fd1034d94a2069c,0x3fd16e78e9efb85b,2
+np.float64,0x3fc74db15b2e9b60,0x3fc790f26e894098,2
+np.float64,0x3fd912a88cb22550,0x3fda7d0ab3b21308,2
+np.float64,0x3fd8948a3bb12914,0x3fd9e8950c7874c8,2
+np.float64,0xbfa7ada5242f5b50,0xbfa7b1f8db50c104,2
+np.float64,0x3feeb2e1c27d65c4,0x3fff000b7d09c9b7,2
+np.float64,0x3fe9d46cbbf3a8da,0x3ff1e6f405265a6e,2
+np.float64,0xbfe2480b77e49017,0xbfe4c83b9b37bf0c,2
+np.float64,0x3fe950ea9372a1d6,0x3ff130e62468bf2c,2
+np.float64,0x3fefa7272a7f4e4e,0x4004d8c9bf31ab58,2
+np.float64,0xbfe7309209ee6124,0xbfed5b94acef917a,2
+np.float64,0x3fd05e8c64a0bd18,0x3fd0bdb11e0903c6,2
+np.float64,0x3fd9236043b246c0,0x3fda90ccbe4bab1e,2
+np.float64,0xbfdc3d6805b87ad0,0xbfde5266e17154c3,2
+np.float64,0x3fe5e6bad76bcd76,0x3feacbc306c63445,2
+np.float64,0x3ff0000000000000,0x7ff0000000000000,2
+np.float64,0xbfde3d7390bc7ae8,0xbfe06cd480bd0196,2
+np.float64,0xbfd3e2e3c0a7c5c8,0xbfd490edc0a45e26,2
+np.float64,0x3fe39871d76730e4,0x3fe6ce54d1719953,2
+np.float64,0x3fdff00ebcbfe01c,0x3fe1894b6655a6d0,2
+np.float64,0x3f91b7ad58236f40,0x3f91b8213bcb8b0b,2
+np.float64,0xbfd99f48f7b33e92,0xbfdb23d544f62591,2
+np.float64,0x3fae3512cc3c6a20,0x3fae3e10939fd7b5,2
+np.float64,0x3fcc4cf3db3899e8,0x3fccc698a15176d6,2
+np.float64,0xbfd0927e39a124fc,0xbfd0f5522e2bc030,2
+np.float64,0x3fcee859633dd0b0,0x3fcf87bdef7a1e82,2
+np.float64,0xbfe2a8b69565516d,0xbfe5593437b6659a,2
+np.float64,0x3fecf61e20f9ec3c,0x3ff7fda16b0209d4,2
+np.float64,0xbfbf37571e3e6eb0,0xbfbf5f4e1379a64c,2
+np.float64,0xbfd54e1b75aa9c36,0xbfd626223b68971a,2
+np.float64,0x3fe1035a56e206b4,0x3fe2f5651ca0f4b0,2
+np.float64,0x3fe4992989e93254,0x3fe876751afa70dc,2
+np.float64,0x3fc8c313d3318628,0x3fc913faf15d1562,2
+np.float64,0x3f99f6ba8833ed80,0x3f99f8274fb94828,2
+np.float64,0xbfd4a58af0a94b16,0xbfd56947c276e04f,2
+np.float64,0x3fc66f8c872cdf18,0x3fc6ab7a14372a73,2
+np.float64,0x3fc41eee0d283de0,0x3fc449ff1ff0e7a6,2
+np.float64,0x3fefd04d287fa09a,0x4007585010cfa9b0,2
+np.float64,0x3fce9e746f3d3ce8,0x3fcf39514bbe5070,2
+np.float64,0xbfe8056f72700adf,0xbfef2ee2c13e67ba,2
+np.float64,0x3fdd6b1ec0bad63c,0x3fdfccf2ba144fa8,2
+np.float64,0x3fd92ee432b25dc8,0x3fda9e6b96b2b142,2
+np.float64,0xbfc4d18f9529a320,0xbfc50150fb4de0cc,2
+np.float64,0xbfe09939a7613274,0xbfe262d703c317af,2
+np.float64,0xbfd130b132a26162,0xbfd19f5a00ae29c4,2
+np.float64,0x3fa06e21d420dc40,0x3fa06f93aba415fb,2
+np.float64,0x3fc5c48fbd2b8920,0x3fc5fb3bfad3bf55,2
+np.float64,0xbfdfa2bacbbf4576,0xbfe155f839825308,2
+np.float64,0x3fe3e1fa0f67c3f4,0x3fe745081dd4fd03,2
+np.float64,0x3fdae58289b5cb04,0x3fdcac1f6789130a,2
+np.float64,0xbf8ed3ba103da780,0xbf8ed452a9cc1442,2
+np.float64,0xbfec06b46f780d69,0xbff5b86f30d70908,2
+np.float64,0xbfe990c13b732182,0xbff187a90ae611f8,2
+np.float64,0xbfdd46c738ba8d8e,0xbfdf9eee0a113230,2
+np.float64,0x3fe08b83f3611708,0x3fe2501b1c77035c,2
+np.float64,0xbfd501b65baa036c,0xbfd5d05de3fceac8,2
+np.float64,0xbfcf4fa21f3e9f44,0xbfcff5829582c0b6,2
+np.float64,0xbfefbc0bfbff7818,0xc005eca1a2c56b38,2
+np.float64,0xbfe1ba6959e374d2,0xbfe3f8f88d128ce5,2
+np.float64,0xbfd4e74ee3a9ce9e,0xbfd5b2cabeb45e6c,2
+np.float64,0xbfe77c38eaeef872,0xbfedfd332d6f1c75,2
+np.float64,0x3fa9b5e4fc336bc0,0x3fa9bb6f6b80b4af,2
+np.float64,0xbfecba63917974c7,0xbff75e44df7f8e81,2
+np.float64,0x3fd6cf17b2ad9e30,0x3fd7db0b93b7f2b5,2

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-log.csv

@@ -0,0 +1,271 @@
+dtype,input,output,ulperrortol
+## +ve denormals ##
+np.float32,0x004b4716,0xc2afbc1b,4
+np.float32,0x007b2490,0xc2aec01e,4
+np.float32,0x007c99fa,0xc2aeba17,4
+np.float32,0x00734a0c,0xc2aee1dc,4
+np.float32,0x0070de24,0xc2aeecba,4
+np.float32,0x007fffff,0xc2aeac50,4
+np.float32,0x00000001,0xc2ce8ed0,4
+## -ve denormals ##
+np.float32,0x80495d65,0xffc00000,4
+np.float32,0x806894f6,0xffc00000,4
+np.float32,0x80555a76,0xffc00000,4
+np.float32,0x804e1fb8,0xffc00000,4
+np.float32,0x80687de9,0xffc00000,4
+np.float32,0x807fffff,0xffc00000,4
+np.float32,0x80000001,0xffc00000,4
+## +/-0.0f, +/-FLT_MIN +/-FLT_MAX ##
+np.float32,0x00000000,0xff800000,4
+np.float32,0x80000000,0xff800000,4
+np.float32,0x7f7fffff,0x42b17218,4
+np.float32,0x80800000,0xffc00000,4
+np.float32,0xff7fffff,0xffc00000,4
+## 1.00f + 0x00000001 ##
+np.float32,0x3f800000,0x00000000,4
+np.float32,0x3f800001,0x33ffffff,4
+np.float32,0x3f800002,0x347ffffe,4
+np.float32,0x3f7fffff,0xb3800000,4
+np.float32,0x3f7ffffe,0xb4000000,4
+np.float32,0x3f7ffffd,0xb4400001,4
+np.float32,0x402df853,0x3f7ffffe,4
+np.float32,0x402df854,0x3f7fffff,4
+np.float32,0x402df855,0x3f800000,4
+np.float32,0x402df856,0x3f800001,4
+np.float32,0x3ebc5ab0,0xbf800001,4
+np.float32,0x3ebc5ab1,0xbf800000,4
+np.float32,0x3ebc5ab2,0xbf800000,4
+np.float32,0x3ebc5ab3,0xbf7ffffe,4
+np.float32,0x423ef575,0x407768ab,4
+np.float32,0x427b8c61,0x408485dd,4
+np.float32,0x4211e9ee,0x406630b0,4
+np.float32,0x424d5c41,0x407c0fed,4
+np.float32,0x42be722a,0x4091cc91,4
+np.float32,0x42b73d30,0x4090908b,4
+np.float32,0x427e48e2,0x4084de7f,4
+np.float32,0x428f759b,0x4088bba3,4
+np.float32,0x41629069,0x4029a0cc,4
+np.float32,0x4272c99d,0x40836379,4
+np.float32,0x4d1b7458,0x4197463d,4
+np.float32,0x4f10c594,0x41ace2b2,4
+np.float32,0x4ea397c2,0x41a85171,4
+np.float32,0x4fefa9d1,0x41b6769c,4
+np.float32,0x4ebac6ab,0x41a960dc,4
+np.float32,0x4f6efb42,0x41b0e535,4
+np.float32,0x4e9ab8e7,0x41a7df44,4
+np.float32,0x4e81b5d1,0x41a67625,4
+np.float32,0x5014d9f2,0x41b832bd,4
+np.float32,0x4f02175c,0x41ac07b8,4
+np.float32,0x7f034f89,0x42b01c47,4
+np.float32,0x7f56d00e,0x42b11849,4
+np.float32,0x7f1cd5f6,0x42b0773a,4
+np.float32,0x7e979174,0x42af02d7,4
+np.float32,0x7f23369f,0x42b08ba2,4
+np.float32,0x7f0637ae,0x42b0277d,4
+np.float32,0x7efcb6e8,0x42b00897,4
+np.float32,0x7f7907c8,0x42b163f6,4
+np.float32,0x7e95c4c2,0x42aefcba,4
+np.float32,0x7f4577b2,0x42b0ed2d,4
+np.float32,0x3f49c92e,0xbe73ae84,4
+np.float32,0x3f4a23d1,0xbe71e2f8,4
+np.float32,0x3f4abb67,0xbe6ee430,4
+np.float32,0x3f48169a,0xbe7c5532,4
+np.float32,0x3f47f5fa,0xbe7cfc37,4
+np.float32,0x3f488309,0xbe7a2ad8,4
+np.float32,0x3f479df4,0xbe7ebf5f,4
+np.float32,0x3f47cfff,0xbe7dbec9,4
+np.float32,0x3f496704,0xbe75a125,4
+np.float32,0x3f478ee8,0xbe7f0c92,4
+np.float32,0x3f4a763b,0xbe7041ce,4
+np.float32,0x3f47a108,0xbe7eaf94,4
+np.float32,0x3f48136c,0xbe7c6578,4
+np.float32,0x3f481c17,0xbe7c391c,4
+np.float32,0x3f47cd28,0xbe7dcd56,4
+np.float32,0x3f478be8,0xbe7f1bf7,4
+np.float32,0x3f4c1f8e,0xbe67e367,4
+np.float32,0x3f489b0c,0xbe79b03f,4
+np.float32,0x3f4934cf,0xbe76a08a,4
+np.float32,0x3f4954df,0xbe75fd6a,4
+np.float32,0x3f47a3f5,0xbe7ea093,4
+np.float32,0x3f4ba4fc,0xbe6a4b02,4
+np.float32,0x3f47a0e1,0xbe7eb05c,4
+np.float32,0x3f48c30a,0xbe78e42f,4
+np.float32,0x3f48cab8,0xbe78bd05,4
+np.float32,0x3f4b0569,0xbe6d6ea4,4
+np.float32,0x3f47de32,0xbe7d7607,4
+np.float32,0x3f477328,0xbe7f9b00,4
+np.float32,0x3f496dab,0xbe757f52,4
+np.float32,0x3f47662c,0xbe7fddac,4
+np.float32,0x3f48ddd8,0xbe785b80,4
+np.float32,0x3f481866,0xbe7c4bff,4
+np.float32,0x3f48b119,0xbe793fb6,4
+np.float32,0x3f48c7e8,0xbe78cb5c,4
+np.float32,0x3f4985f6,0xbe7503da,4
+np.float32,0x3f483fdf,0xbe7b8212,4
+np.float32,0x3f4b1c76,0xbe6cfa67,4
+np.float32,0x3f480b2e,0xbe7c8fa8,4
+np.float32,0x3f48745f,0xbe7a75bf,4
+np.float32,0x3f485bda,0xbe7af308,4
+np.float32,0x3f47a660,0xbe7e942c,4
+np.float32,0x3f47d4d5,0xbe7da600,4
+np.float32,0x3f4b0a26,0xbe6d56be,4
+np.float32,0x3f4a4883,0xbe712924,4
+np.float32,0x3f4769e7,0xbe7fca84,4
+np.float32,0x3f499702,0xbe74ad3f,4
+np.float32,0x3f494ab1,0xbe763131,4
+np.float32,0x3f476b69,0xbe7fc2c6,4
+np.float32,0x3f4884e8,0xbe7a214a,4
+np.float32,0x3f486945,0xbe7aae76,4
+#float64
+## +ve denormal ##
+np.float64,0x0000000000000001,0xc0874385446d71c3,2
+np.float64,0x0001000000000000,0xc086395a2079b70c,2
+np.float64,0x000fffffffffffff,0xc086232bdd7abcd2,2
+np.float64,0x0007ad63e2168cb6,0xc086290bc0b2980f,2
+## -ve denormal ##
+np.float64,0x8000000000000001,0xfff8000000000001,2
+np.float64,0x8001000000000000,0xfff8000000000001,2
+np.float64,0x800fffffffffffff,0xfff8000000000001,2
+np.float64,0x8007ad63e2168cb6,0xfff8000000000001,2
+## +/-0.0f, MAX, MIN##
+np.float64,0x0000000000000000,0xfff0000000000000,2
+np.float64,0x8000000000000000,0xfff0000000000000,2
+np.float64,0x7fefffffffffffff,0x40862e42fefa39ef,2
+np.float64,0xffefffffffffffff,0xfff8000000000001,2
+## near 1.0f ##
+np.float64,0x3ff0000000000000,0x0000000000000000,2
+np.float64,0x3fe8000000000000,0xbfd269621134db92,2
+np.float64,0x3ff0000000000001,0x3cafffffffffffff,2
+np.float64,0x3ff0000020000000,0x3e7fffffe000002b,2
+np.float64,0x3ff0000000000001,0x3cafffffffffffff,2
+np.float64,0x3fefffffe0000000,0xbe70000008000005,2
+np.float64,0x3fefffffffffffff,0xbca0000000000000,2
+## random numbers ##
+np.float64,0x02500186f3d9da56,0xc0855b8abf135773,2
+np.float64,0x09200815a3951173,0xc082ff1ad7131bdc,2
+np.float64,0x0da029623b0243d4,0xc0816fc994695bb5,2
+np.float64,0x48703b8ac483a382,0x40579213a313490b,2
+np.float64,0x09207b74c87c9860,0xc082fee20ff349ef,2
+np.float64,0x62c077698e8df947,0x407821c996d110f0,2
+np.float64,0x2350b45e87c3cfb0,0xc073d6b16b51d072,2
+np.float64,0x3990a23f9ff2b623,0xc051aa60eadd8c61,2
+np.float64,0x0d011386a116c348,0xc081a6cc7ea3b8fb,2
+np.float64,0x1fe0f0303ebe273a,0xc0763870b78a81ca,2
+np.float64,0x0cd1260121d387da,0xc081b7668d61a9d1,2
+np.float64,0x1e6135a8f581d422,0xc077425ac10f08c2,2
+np.float64,0x622168db5fe52d30,0x4077b3c669b9fadb,2
+np.float64,0x69f188e1ec6d1718,0x407d1e2f18c63889,2
+np.float64,0x3aa1bf1d9c4dd1a3,0xc04d682e24bde479,2
+np.float64,0x6c81c4011ce4f683,0x407ee5190e8a8e6a,2
+np.float64,0x2191fa55aa5a5095,0xc0750c0c318b5e2d,2
+np.float64,0x32a1f602a32bf360,0xc06270caa493fc17,2
+np.float64,0x16023c90ba93249b,0xc07d0f88e0801638,2
+np.float64,0x1c525fe6d71fa9ff,0xc078af49c66a5d63,2
+np.float64,0x1a927675815d65b7,0xc079e5bdd7fe376e,2
+np.float64,0x41227b8fe70da028,0x402aa0c9f9a84c71,2
+np.float64,0x4962bb6e853fe87d,0x405a34aa04c83747,2
+np.float64,0x23d2cda00b26b5a4,0xc0737c13a06d00ea,2
+np.float64,0x2d13083fd62987fa,0xc06a25055aeb474e,2
+np.float64,0x10e31e4c9b4579a1,0xc0804e181929418e,2
+np.float64,0x26d3247d556a86a9,0xc0716774171da7e8,2
+np.float64,0x6603379398d0d4ac,0x407a64f51f8a887b,2
+np.float64,0x02d38af17d9442ba,0xc0852d955ac9dd68,2
+np.float64,0x6a2382b4818dd967,0x407d4129d688e5d4,2
+np.float64,0x2ee3c403c79b3934,0xc067a091fefaf8b6,2
+np.float64,0x6493a699acdbf1a4,0x4079663c8602bfc5,2
+np.float64,0x1c8413c4f0de3100,0xc0788c99697059b6,2
+np.float64,0x4573f1ed350d9622,0x404e9bd1e4c08920,2
+np.float64,0x2f34265c9200b69c,0xc067310cfea4e986,2
+np.float64,0x19b43e65fa22029b,0xc07a7f8877de22d6,2
+np.float64,0x0af48ab7925ed6bc,0xc0825c4fbc0e5ade,2
+np.float64,0x4fa49699cad82542,0x4065c76d2a318235,2
+np.float64,0x7204a15e56ade492,0x40815bb87484dffb,2
+np.float64,0x4734aa08a230982d,0x40542a4bf7a361a9,2
+np.float64,0x1ae4ed296c2fd749,0xc079ac4921f20abb,2
+np.float64,0x472514ea4370289c,0x4053ff372bd8f18f,2
+np.float64,0x53a54b3f73820430,0x406b5411fc5f2e33,2
+np.float64,0x64754de5a15684fa,0x407951592e99a5ab,2
+np.float64,0x69358e279868a7c3,0x407c9c671a882c31,2
+np.float64,0x284579ec61215945,0xc0706688e55f0927,2
+np.float64,0x68b5c58806447adc,0x407c43d6f4eff760,2
+np.float64,0x1945a83f98b0e65d,0xc07acc15eeb032cc,2
+np.float64,0x0fc5eb98a16578bf,0xc080b0d02eddca0e,2
+np.float64,0x6a75e208f5784250,0x407d7a7383bf8f05,2
+np.float64,0x0fe63a029c47645d,0xc080a59ca1e98866,2
+np.float64,0x37963ac53f065510,0xc057236281f7bdb6,2
+np.float64,0x135661bb07067ff7,0xc07ee924930c21e4,2
+np.float64,0x4b4699469d458422,0x405f73843756e887,2
+np.float64,0x1a66d73e4bf4881b,0xc07a039ba1c63adf,2
+np.float64,0x12a6b9b119a7da59,0xc07f62e49c6431f3,2
+np.float64,0x24c719aa8fd1bdb5,0xc072d26da4bf84d3,2
+np.float64,0x0fa6ff524ffef314,0xc080bb8514662e77,2
+np.float64,0x1db751d66fdd4a9a,0xc077b77cb50d7c92,2
+np.float64,0x4947374c516da82c,0x4059e9acfc7105bf,2
+np.float64,0x1b1771ab98f3afc8,0xc07989326b8e1f66,2
+np.float64,0x25e78805baac8070,0xc0720a818e6ef080,2
+np.float64,0x4bd7a148225d3687,0x406082d004ea3ee7,2
+np.float64,0x53d7d6b2bbbda00a,0x406b9a398967cbd5,2
+np.float64,0x6997fb9f4e1c685f,0x407ce0a703413eba,2
+np.float64,0x069802c2ff71b951,0xc083df39bf7acddc,2
+np.float64,0x4d683ac9890f66d8,0x4062ae21d8c2acf0,2
+np.float64,0x5a2825863ec14f4c,0x40722d718d549552,2
+np.float64,0x0398799a88f4db80,0xc084e93dab8e2158,2
+np.float64,0x5ed87a8b77e135a5,0x40756d7051777b33,2
+np.float64,0x5828cd6d79b9bede,0x4070cafb22fc6ca1,2
+np.float64,0x7b18ba2a5ec6f068,0x408481386b3ed6fe,2
+np.float64,0x4938fd60922198fe,0x4059c206b762ea7e,2
+np.float64,0x31b8f44fcdd1a46e,0xc063b2faa8b6434e,2
+np.float64,0x5729341c0d918464,0x407019cac0c4a7d7,2
+np.float64,0x13595e9228ee878e,0xc07ee7235a7d8088,2
+np.float64,0x17698b0dc9dd4135,0xc07c1627e3a5ad5f,2
+np.float64,0x63b977c283abb0cc,0x4078cf1ec6ed65be,2
+np.float64,0x7349cc0d4dc16943,0x4081cc697ce4cb53,2
+np.float64,0x4e49a80b732fb28d,0x4063e67e3c5cbe90,2
+np.float64,0x07ba14b848a8ae02,0xc0837ac032a094e0,2
+np.float64,0x3da9f17b691bfddc,0xc03929c25366acda,2
+np.float64,0x02ea39aa6c3ac007,0xc08525af6f21e1c4,2
+np.float64,0x3a6a42f04ed9563d,0xc04e98e825dca46b,2
+np.float64,0x1afa877cd7900be7,0xc0799d6648cb34a9,2
+np.float64,0x58ea986649e052c6,0x4071512e939ad790,2
+np.float64,0x691abbc04647f536,0x407c89aaae0fcb83,2
+np.float64,0x43aabc5063e6f284,0x4044b45d18106fd2,2
+np.float64,0x488b003c893e0bea,0x4057df012a2dafbe,2
+np.float64,0x77eb076ed67caee5,0x40836720de94769e,2
+np.float64,0x5c1b46974aba46f4,0x40738731ba256007,2
+np.float64,0x1a5b29ecb5d3c261,0xc07a0becc77040d6,2
+np.float64,0x5d8b6ccf868c6032,0x4074865c1865e2db,2
+np.float64,0x4cfb6690b4aaf5af,0x406216cd8c7e8ddb,2
+np.float64,0x76cbd8eb5c5fc39e,0x4083038dc66d682b,2
+np.float64,0x28bbd1fec5012814,0xc07014c2dd1b9711,2
+np.float64,0x33dc1b3a4fd6bf7a,0xc060bd0756e07d8a,2
+np.float64,0x52bbe89b37de99f3,0x406a10041aa7d343,2
+np.float64,0x07bc479d15eb2dd3,0xc0837a1a6e3a3b61,2
+np.float64,0x18fc5275711a901d,0xc07aff3e9d62bc93,2
+np.float64,0x114c9758e247dc71,0xc080299a7cf15b05,2
+np.float64,0x25ac8f6d60755148,0xc07233c4c0c511d4,2
+np.float64,0x260cae2bb9e9fd7e,0xc071f128c7e82eac,2
+np.float64,0x572ccdfe0241de82,0x40701bedc84bb504,2
+np.float64,0x0ddcef6c8d41f5ee,0xc0815a7e16d07084,2
+np.float64,0x6dad1d59c988af68,0x407fb4a0bc0142b1,2
+np.float64,0x025d200580d8b6d1,0xc08556c0bc32b1b2,2
+np.float64,0x7aad344b6aa74c18,0x40845bbc453f22be,2
+np.float64,0x5b5d9d6ad9d14429,0x4073036d2d21f382,2
+np.float64,0x49cd8d8dcdf19954,0x405b5c034f5c7353,2
+np.float64,0x63edb9483335c1e6,0x4078f2dd21378786,2
+np.float64,0x7b1dd64c9d2c26bd,0x408482b922017bc9,2
+np.float64,0x782e13e0b574be5f,0x40837e2a0090a5ad,2
+np.float64,0x592dfe18b9d6db2f,0x40717f777fbcb1ec,2
+np.float64,0x654e3232ac60d72c,0x4079e71a95a70446,2
+np.float64,0x7b8e42ad22091456,0x4084a9a6f1e61722,2
+np.float64,0x570e88dfd5860ae6,0x407006ae6c0d137a,2
+np.float64,0x294e98346cb98ef1,0xc06f5edaac12bd44,2
+np.float64,0x1adeaa4ab792e642,0xc079b1431d5e2633,2
+np.float64,0x7b6ead3377529ac8,0x40849eabc8c7683c,2
+np.float64,0x2b8eedae8a9b2928,0xc06c400054deef11,2
+np.float64,0x65defb45b2dcf660,0x407a4b53f181c05a,2
+np.float64,0x1baf582d475e7701,0xc07920bcad4a502c,2
+np.float64,0x461f39cf05a0f15a,0x405126368f984fa1,2
+np.float64,0x7e5f6f5dcfff005b,0x4085a37d610439b4,2
+np.float64,0x136f66e4d09bd662,0xc07ed8a2719f2511,2
+np.float64,0x65afd8983fb6ca1f,0x407a2a7f48bf7fc1,2
+np.float64,0x572fa7f95ed22319,0x40701d706cf82e6f,2

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-log2.csv

@@ -0,0 +1,1629 @@
+dtype,input,output,ulperrortol
+np.float32,0x80000000,0xff800000,3
+np.float32,0x7f12870a,0x42fe63db,3
+np.float32,0x3ef29cf5,0xbf89eb12,3
+np.float32,0x3d6ba8fb,0xc083d26c,3
+np.float32,0x3d9907e8,0xc06f8230,3
+np.float32,0x4ee592,0xc2fd656e,3
+np.float32,0x58d8b1,0xc2fd0db3,3
+np.float32,0x7ba103,0xc2fc19aa,3
+np.float32,0x7f52e90e,0x42ff70e4,3
+np.float32,0x7fcb15,0xc2fc0132,3
+np.float32,0x7cb7129f,0x42f50855,3
+np.float32,0x9faba,0xc301ae59,3
+np.float32,0x7f300a,0xc2fc04b4,3
+np.float32,0x3f0bf047,0xbf5f10cb,3
+np.float32,0x2fb1fb,0xc2fed934,3
+np.float32,0x3eedb0d1,0xbf8db417,3
+np.float32,0x3d7a0b40,0xc0811638,3
+np.float32,0x2e0bac,0xc2fef334,3
+np.float32,0x6278c1,0xc2fcc1b9,3
+np.float32,0x7f61ab2e,0x42ffa2d9,3
+np.float32,0x8fe7c,0xc301d4be,3
+np.float32,0x3f25e6ee,0xbf203536,3
+np.float32,0x7efc78f0,0x42fdf5c0,3
+np.float32,0x6d7304,0xc2fc73a7,3
+np.float32,0x7f1a472a,0x42fe89ed,3
+np.float32,0x7dd029a6,0x42f96734,3
+np.float32,0x3e9b9327,0xbfdbf8f7,3
+np.float32,0x3f4eefc1,0xbe9d2942,3
+np.float32,0x7f5b9b64,0x42ff8ebc,3
+np.float32,0x3e458ee1,0xc017ed6e,3
+np.float32,0x3f7b766b,0xbcd35acf,3
+np.float32,0x3e616070,0xc00bc378,3
+np.float32,0x7f20e633,0x42fea8f8,3
+np.float32,0x3ee3b461,0xbf95a126,3
+np.float32,0x7e7722ba,0x42fbe5f8,3
+np.float32,0x3f0873d7,0xbf6861fa,3
+np.float32,0x7b4cb2,0xc2fc1ba3,3
+np.float32,0x3f0b6b02,0xbf60712e,3
+np.float32,0x9bff4,0xc301b6f2,3
+np.float32,0x3f07be25,0xbf6a4f0c,3
+np.float32,0x3ef10e57,0xbf8b1b75,3
+np.float32,0x46ad75,0xc2fdb6b1,3
+np.float32,0x3f7bc542,0xbcc4e3a9,3
+np.float32,0x3f6673d4,0xbe1b509c,3
+np.float32,0x7f19fe59,0x42fe8890,3
+np.float32,0x7f800000,0x7f800000,3
+np.float32,0x7f2fe696,0x42feead0,3
+np.float32,0x3dc9432d,0xc0563655,3
+np.float32,0x3ee47623,0xbf950446,3
+np.float32,0x3f1f8817,0xbf2eab51,3
+np.float32,0x7f220ec5,0x42feae44,3
+np.float32,0x2325e3,0xc2ffbab1,3
+np.float32,0x29dfc8,0xc2ff395a,3
+np.float32,0x7f524950,0x42ff6eb3,3
+np.float32,0x3e2234e0,0xc02a21c8,3
+np.float32,0x7f1c6f5a,0x42fe942f,3
+np.float32,0x3b6a61,0xc2fe36e7,3
+np.float32,0x3f1df90e,0xbf324ba9,3
+np.float32,0xb57f0,0xc3017f07,3
+np.float32,0x7d0eba,0xc2fc112e,3
+np.float32,0x403aa9,0xc2fdfd5c,3
+np.float32,0x3e74ecc7,0xc004155f,3
+np.float32,0x17509c,0xc30074f2,3
+np.float32,0x7f62196b,0x42ffa442,3
+np.float32,0x3ecef9a9,0xbfa7417a,3
+np.float32,0x7f14b158,0x42fe6eb1,3
+np.float32,0x3ede12be,0xbf9a40fe,3
+np.float32,0x42cfaa,0xc2fde03f,3
+np.float32,0x3f407b0f,0xbed2a6f5,3
+np.float32,0x7f7fffff,0x43000000,3
+np.float32,0x5467c6,0xc2fd3394,3
+np.float32,0x7ea6b80f,0x42fcc336,3
+np.float32,0x3f21e7b2,0xbf293704,3
+np.float32,0x3dc7e9eb,0xc056d542,3
+np.float32,0x7f3e6e67,0x42ff2571,3
+np.float32,0x3e3e809d,0xc01b4911,3
+np.float32,0x3f800000,0x0,3
+np.float32,0x3d8fd238,0xc0753d52,3
+np.float32,0x3f74aa65,0xbd85cd0e,3
+np.float32,0x7ec30305,0x42fd36ff,3
+np.float32,0x3e97bb93,0xbfe0971d,3
+np.float32,0x3e109d9c,0xc034bb1b,3
+np.float32,0x3f4a0b67,0xbeaed537,3
+np.float32,0x3f25a7aa,0xbf20c228,3
+np.float32,0x3ebc05eb,0xbfb8fd6b,3
+np.float32,0x3eebe749,0xbf8f18e5,3
+np.float32,0x3e9dc479,0xbfd96356,3
+np.float32,0x7f245200,0x42feb882,3
+np.float32,0x1573a8,0xc30093b5,3
+np.float32,0x3e66c4b9,0xc00994a6,3
+np.float32,0x3e73bffc,0xc0048709,3
+np.float32,0x3dfef8e5,0xc0405f16,3
+np.float32,0x403750,0xc2fdfd83,3
+np.float32,0x3ebedf17,0xbfb636a4,3
+np.float32,0x15cae6,0xc3008de2,3
+np.float32,0x3edf4d4e,0xbf993c24,3
+np.float32,0x3f7cc41e,0xbc963fb3,3
+np.float32,0x3e9e12a4,0xbfd907ee,3
+np.float32,0x7ded7b59,0x42f9c889,3
+np.float32,0x7f034878,0x42fe12b5,3
+np.float32,0x7ddce43f,0x42f9930b,3
+np.float32,0x3d82b257,0xc07e1333,3
+np.float32,0x3dae89c1,0xc0635dd4,3
+np.float32,0x6b1d00,0xc2fc8396,3
+np.float32,0x449a5a,0xc2fdccb3,3
+np.float32,0x4e89d2,0xc2fd68cb,3
+np.float32,0x7e1ae83f,0x42fa8cef,3
+np.float32,0x7e4bb22c,0x42fb572e,3
+np.float32,0x3de308ea,0xc04b1634,3
+np.float32,0x7f238c7a,0x42feb508,3
+np.float32,0x3f6c62a3,0xbdeb86f3,3
+np.float32,0x3e58cba6,0xc00f5908,3
+np.float32,0x7f7dd91f,0x42fff9c4,3
+np.float32,0x3d989376,0xc06fc88d,3
+np.float32,0x3dd013c5,0xc0532339,3
+np.float32,0x4b17e6,0xc2fd89ed,3
+np.float32,0x7f67f287,0x42ffb71e,3
+np.float32,0x3f69365e,0xbe09ba3c,3
+np.float32,0x3e4b8b21,0xc0152bf1,3
+np.float32,0x3a75b,0xc3032171,3
+np.float32,0x7f303676,0x42feec1f,3
+np.float32,0x7f6570e5,0x42ffaf18,3
+np.float32,0x3f5ed61e,0xbe4cf676,3
+np.float32,0x3e9b22f9,0xbfdc7e4f,3
+np.float32,0x2c095e,0xc2ff1428,3
+np.float32,0x3f1b17c1,0xbf391754,3
+np.float32,0x422dc6,0xc2fde746,3
+np.float32,0x3f677c8d,0xbe14b365,3
+np.float32,0x3ef85d0c,0xbf8597a9,3
+np.float32,0x3ecaaa6b,0xbfab2430,3
+np.float32,0x3f0607d1,0xbf6eff3d,3
+np.float32,0x3f011fdb,0xbf7cc50d,3
+np.float32,0x6ed7c1,0xc2fc6a4e,3
+np.float32,0x7ec2d1a2,0x42fd3644,3
+np.float32,0x3f75b7fe,0xbd7238a2,3
+np.float32,0x3ef2d146,0xbf89c344,3
+np.float32,0x7ec2cd27,0x42fd3633,3
+np.float32,0x7ee1e55a,0x42fda397,3
+np.float32,0x7f464d6a,0x42ff435c,3
+np.float32,0x7f469a93,0x42ff447b,3
+np.float32,0x7ece752f,0x42fd6121,3
+np.float32,0x2ed878,0xc2fee67b,3
+np.float32,0x75b23,0xc3021eff,3
+np.float32,0x3e0f4be4,0xc03593b8,3
+np.float32,0x2778e1,0xc2ff64fc,3
+np.float32,0x5fe2b7,0xc2fcd561,3
+np.float32,0x19b8a9,0xc30050ab,3
+np.float32,0x7df303e5,0x42f9d98d,3
+np.float32,0x608b8d,0xc2fcd051,3
+np.float32,0x588f46,0xc2fd1017,3
+np.float32,0x3eec6a11,0xbf8eb2a1,3
+np.float32,0x3f714121,0xbdaf4906,3
+np.float32,0x7f4f7b9e,0x42ff64c9,3
+np.float32,0x3c271606,0xc0d3b29c,3
+np.float32,0x3f002fe0,0xbf7f75f6,3
+np.float32,0x7efa4798,0x42fdef4f,3
+np.float32,0x3f61a865,0xbe3a601a,3
+np.float32,0x7e8087aa,0x42fc030d,3
+np.float32,0x3f70f0c7,0xbdb321ba,3
+np.float32,0x5db898,0xc2fce63f,3
+np.float32,0x7a965f,0xc2fc1fea,3
+np.float32,0x7f68b112,0x42ffb97c,3
+np.float32,0x7ef0ed3d,0x42fdd32d,3
+np.float32,0x7f3156a1,0x42fef0d3,3
+np.float32,0x3f1d405f,0xbf33fc6e,3
+np.float32,0x3e3494cf,0xc0203945,3
+np.float32,0x6018de,0xc2fcd3c1,3
+np.float32,0x623e49,0xc2fcc370,3
+np.float32,0x3ea29f0f,0xbfd3cad4,3
+np.float32,0xa514,0xc305a20c,3
+np.float32,0x3e1b2ab1,0xc02e3a8f,3
+np.float32,0x3f450b6f,0xbec1578f,3
+np.float32,0x7eb12908,0x42fcf015,3
+np.float32,0x3f10b720,0xbf52ab48,3
+np.float32,0x3e0a93,0xc2fe16f6,3
+np.float32,0x93845,0xc301cb96,3
+np.float32,0x7f4e9ce3,0x42ff61af,3
+np.float32,0x3f6d4296,0xbde09ceb,3
+np.float32,0x6ddede,0xc2fc70d0,3
+np.float32,0x3f4fb6fd,0xbe9a636d,3
+np.float32,0x3f6d08de,0xbde36c0b,3
+np.float32,0x3f56f057,0xbe8122ad,3
+np.float32,0x334e95,0xc2fea349,3
+np.float32,0x7efadbcd,0x42fdf104,3
+np.float32,0x3db02e88,0xc0628046,3
+np.float32,0x3f3309d1,0xbf041066,3
+np.float32,0x2d8722,0xc2fefb8f,3
+np.float32,0x7e926cac,0x42fc6356,3
+np.float32,0x3e3674ab,0xc01f452e,3
+np.float32,0x1b46ce,0xc3003afc,3
+np.float32,0x3f06a338,0xbf6d53fc,3
+np.float32,0x1b1ba7,0xc3003d46,3
+np.float32,0x319dfb,0xc2febc06,3
+np.float32,0x3e2f126a,0xc02315a5,3
+np.float32,0x3f40fe65,0xbed0af9e,3
+np.float32,0x3f1d842f,0xbf335d4b,3
+np.float32,0x3d044e4f,0xc09e78f8,3
+np.float32,0x7f272674,0x42fec51f,3
+np.float32,0x3cda6d8f,0xc0a753db,3
+np.float32,0x3eb92f12,0xbfbbccbb,3
+np.float32,0x7e4318f4,0x42fb3752,3
+np.float32,0x3c5890,0xc2fe2b6d,3
+np.float32,0x3d1993c9,0xc09796f8,3
+np.float32,0x7f18ef24,0x42fe8377,3
+np.float32,0x3e30c3a0,0xc0223244,3
+np.float32,0x3f27cd27,0xbf1c00ef,3
+np.float32,0x3f150957,0xbf47cd6c,3
+np.float32,0x7e7178a3,0x42fbd4d8,3
+np.float32,0x3f298db8,0xbf182ac3,3
+np.float32,0x7cb3be,0xc2fc1348,3
+np.float32,0x3ef64266,0xbf8729de,3
+np.float32,0x3eeb06ce,0xbf8fc8f2,3
+np.float32,0x3f406e36,0xbed2d845,3
+np.float32,0x7f1e1bd3,0x42fe9c0b,3
+np.float32,0x478dcc,0xc2fdad97,3
+np.float32,0x7f7937b5,0x42ffec2b,3
+np.float32,0x3f20f350,0xbf2b6624,3
+np.float32,0x7f13661a,0x42fe683c,3
+np.float32,0x208177,0xc2fff46b,3
+np.float32,0x263cfb,0xc2ff7c72,3
+np.float32,0x7f0bd28c,0x42fe4141,3
+np.float32,0x7230d8,0xc2fc5453,3
+np.float32,0x3f261bbf,0xbf1fbfb4,3
+np.float32,0x737b56,0xc2fc4c05,3
+np.float32,0x3ef88f33,0xbf857263,3
+np.float32,0x7e036464,0x42fa1352,3
+np.float32,0x4b5c4f,0xc2fd874d,3
+np.float32,0x3f77984d,0xbd454596,3
+np.float32,0x3f674202,0xbe162932,3
+np.float32,0x3e7157d9,0xc0057197,3
+np.float32,0x3f3f21da,0xbed7d861,3
+np.float32,0x7f1fb40f,0x42fea375,3
+np.float32,0x7ef0157f,0x42fdd096,3
+np.float32,0x3f71e88d,0xbda74962,3
+np.float32,0x3f174855,0xbf424728,3
+np.float32,0x3f3fdd2c,0xbed505d5,3
+np.float32,0x7b95d1,0xc2fc19ed,3
+np.float32,0x7f23f4e5,0x42feb6df,3
+np.float32,0x7d741925,0x42f7dcd6,3
+np.float32,0x60f81d,0xc2fccd14,3
+np.float32,0x3f17d267,0xbf40f6ae,3
+np.float32,0x3f036fc8,0xbf7636f8,3
+np.float32,0x167653,0xc30082b5,3
+np.float32,0x256d05,0xc2ff8c4f,3
+np.float32,0x3eccc63d,0xbfa93adb,3
+np.float32,0x7f6c91ea,0x42ffc5b2,3
+np.float32,0x2ee52a,0xc2fee5b3,3
+np.float32,0x3dc3579e,0xc058f80d,3
+np.float32,0x4c7170,0xc2fd7cc4,3
+np.float32,0x7f737f20,0x42ffdb03,3
+np.float32,0x3f2f9dbf,0xbf0b3119,3
+np.float32,0x3f4d0c54,0xbea3eec5,3
+np.float32,0x7e380862,0x42fb0c32,3
+np.float32,0x5d637f,0xc2fce8df,3
+np.float32,0x3f0aa623,0xbf627c27,3
+np.float32,0x3e4d5896,0xc0145b88,3
+np.float32,0x3f6cacdc,0xbde7e7ca,3
+np.float32,0x63a2c3,0xc2fcb90a,3
+np.float32,0x6c138c,0xc2fc7cfa,3
+np.float32,0x2063c,0xc303fb88,3
+np.float32,0x7e9e5a3e,0x42fc9d2f,3
+np.float32,0x56ec64,0xc2fd1ddd,3
+np.float32,0x7f1d6a35,0x42fe98cc,3
+np.float32,0x73dc96,0xc2fc4998,3
+np.float32,0x3e5d74e5,0xc00d6238,3
+np.float32,0x7f033cbb,0x42fe1273,3
+np.float32,0x3f5143fc,0xbe94e4e7,3
+np.float32,0x1d56d9,0xc3002010,3
+np.float32,0x2bf3e4,0xc2ff1591,3
+np.float32,0x3f2a6ef1,0xbf164170,3
+np.float32,0x3f33238b,0xbf03db58,3
+np.float32,0x22780e,0xc2ffc91a,3
+np.float32,0x7f00b873,0x42fe0425,3
+np.float32,0x3f7f6145,0xbb654706,3
+np.float32,0x7fc00000,0x7fc00000,3
+np.float32,0x63895a,0xc2fcb9c7,3
+np.float32,0x18a1b2,0xc30060a8,3
+np.float32,0x7e43c6a6,0x42fb39e3,3
+np.float32,0x78676e,0xc2fc2d30,3
+np.float32,0x3f16d839,0xbf435940,3
+np.float32,0x7eff78ba,0x42fdfe79,3
+np.float32,0x3f2e152c,0xbf0e6e54,3
+np.float32,0x3db20ced,0xc06186e1,3
+np.float32,0x3f0cd1d8,0xbf5cbf57,3
+np.float32,0x3fd7a8,0xc2fe01d2,3
+np.float32,0x3ebb075e,0xbfb9f816,3
+np.float32,0x7f94ef,0xc2fc026b,3
+np.float32,0x3d80ba0e,0xc07f7a2b,3
+np.float32,0x7f227e15,0x42feb03f,3
+np.float32,0x792264bf,0x42e6afcc,3
+np.float32,0x7f501576,0x42ff66ec,3
+np.float32,0x223629,0xc2ffcea3,3
+np.float32,0x40a79e,0xc2fdf87b,3
+np.float32,0x449483,0xc2fdccf2,3
+np.float32,0x3f4fa978,0xbe9a9382,3
+np.float32,0x7f148c53,0x42fe6df9,3
+np.float32,0x3ec98b3c,0xbfac2a98,3
+np.float32,0x3e4da320,0xc0143a0a,3
+np.float32,0x3d1d94bb,0xc09666d0,3
+np.float32,0x3c8e624e,0xc0bb155b,3
+np.float32,0x66a9af,0xc2fca2ef,3
+np.float32,0x3ec76ed7,0xbfae1c57,3
+np.float32,0x3f4b52f3,0xbeaa2b81,3
+np.float32,0x7e99bbb5,0x42fc8750,3
+np.float32,0x3f69a46b,0xbe0701be,3
+np.float32,0x3f775400,0xbd4ba495,3
+np.float32,0x131e56,0xc300be3c,3
+np.float32,0x3f30abb4,0xbf08fb10,3
+np.float32,0x7f7e528c,0x42fffb25,3
+np.float32,0x3eb89515,0xbfbc668a,3
+np.float32,0x7e9191b6,0x42fc5f02,3
+np.float32,0x7e80c7e9,0x42fc047e,3
+np.float32,0x3f77ef58,0xbd3d2995,3
+np.float32,0x7ddb1f8a,0x42f98d1b,3
+np.float32,0x7ebc6c4f,0x42fd1d9c,3
+np.float32,0x3f6638e0,0xbe1ccab8,3
+np.float32,0x7f4c45,0xc2fc0410,3
+np.float32,0x3e7d8aad,0xc000e414,3
+np.float32,0x3f4d148b,0xbea3d12e,3
+np.float32,0x3e98c45c,0xbfdf55f4,3
+np.float32,0x3d754c78,0xc081f8a9,3
+np.float32,0x17e4cf,0xc3006be3,3
+np.float32,0x7eb65814,0x42fd0563,3
+np.float32,0x3f65e0d8,0xbe1f0008,3
+np.float32,0x3e99541f,0xbfdea87e,3
+np.float32,0x3f3cb80e,0xbee13b27,3
+np.float32,0x3e99f0c0,0xbfddec3b,3
+np.float32,0x3f43903e,0xbec6ea66,3
+np.float32,0x7e211cd4,0x42faa9f2,3
+np.float32,0x824af,0xc301f971,3
+np.float32,0x3e16a56e,0xc030f56c,3
+np.float32,0x542b3b,0xc2fd35a6,3
+np.float32,0x3eeea2d1,0xbf8cf873,3
+np.float32,0x232e93,0xc2ffb9fa,3
+np.float32,0x3e8c52b9,0xbfef06aa,3
+np.float32,0x7f69c7e3,0x42ffbcef,3
+np.float32,0x3f573e43,0xbe801714,3
+np.float32,0x43b009,0xc2fdd69f,3
+np.float32,0x3ee571ab,0xbf943966,3
+np.float32,0x3ee3d5d8,0xbf958604,3
+np.float32,0x338b12,0xc2fe9fe4,3
+np.float32,0x29cb1f,0xc2ff3ac6,3
+np.float32,0x3f0892b4,0xbf680e7a,3
+np.float32,0x3e8c4f7f,0xbfef0ae9,3
+np.float32,0x7c9d3963,0x42f497e6,3
+np.float32,0x3f26ba84,0xbf1e5f59,3
+np.float32,0x3dd0acc0,0xc052df6f,3
+np.float32,0x3e43fbda,0xc018aa8c,3
+np.float32,0x3ec4fd0f,0xbfb0635d,3
+np.float32,0x3f52c8c6,0xbe8f8d85,3
+np.float32,0x3f5fdc5d,0xbe462fdb,3
+np.float32,0x3f461920,0xbebd6743,3
+np.float32,0x6161ff,0xc2fcc9ef,3
+np.float32,0x7f7ed306,0x42fffc9a,3
+np.float32,0x3d212263,0xc0955f46,3
+np.float32,0x3eca5826,0xbfab6f36,3
+np.float32,0x7d6317ac,0x42f7a77e,3
+np.float32,0x3eb02063,0xbfc50f60,3
+np.float32,0x7f71a6f8,0x42ffd565,3
+np.float32,0x1a3efe,0xc3004935,3
+np.float32,0x3dc599c9,0xc057e856,3
+np.float32,0x3f3e1301,0xbedbf205,3
+np.float32,0xf17d4,0xc301158d,3
+np.float32,0x3f615f84,0xbe3c3d85,3
+np.float32,0x3de63be1,0xc049cb77,3
+np.float32,0x3e8d2f51,0xbfede541,3
+np.float32,0x3a5cdd,0xc2fe441c,3
+np.float32,0x3f443ec0,0xbec4586a,3
+np.float32,0x3eacbd00,0xbfc8a5ad,3
+np.float32,0x3f600f6a,0xbe44df1b,3
+np.float32,0x5f77a6,0xc2fcd89c,3
+np.float32,0x476706,0xc2fdaf28,3
+np.float32,0x2f469,0xc3036fde,3
+np.float32,0x7dc4ba24,0x42f93d77,3
+np.float32,0x3e2d6080,0xc023fb9b,3
+np.float32,0x7e8d7135,0x42fc49c3,3
+np.float32,0x3f589065,0xbe77247b,3
+np.float32,0x3f59e210,0xbe6e2c05,3
+np.float32,0x7f51d388,0x42ff6d15,3
+np.float32,0x7d9a5fda,0x42f88a63,3
+np.float32,0x3e67d5bc,0xc00927ab,3
+np.float32,0x61d72c,0xc2fcc679,3
+np.float32,0x3ef3351d,0xbf897766,3
+np.float32,0x1,0xc3150000,3
+np.float32,0x7f653429,0x42ffae54,3
+np.float32,0x7e1ad3e5,0x42fa8c8e,3
+np.float32,0x3f4ca01d,0xbea57500,3
+np.float32,0x3f7606db,0xbd6ad13e,3
+np.float32,0x7ec4a27d,0x42fd3d1f,3
+np.float32,0x3efe4fd5,0xbf8138c7,3
+np.float32,0x77c2f1,0xc2fc3124,3
+np.float32,0x7e4d3251,0x42fb5c9a,3
+np.float32,0x3f543ac7,0xbe8a8154,3
+np.float32,0x7c3dbe29,0x42f322c4,3
+np.float32,0x408e01,0xc2fdf9a0,3
+np.float32,0x45069b,0xc2fdc829,3
+np.float32,0x3d7ecab7,0xc08037e8,3
+np.float32,0xf8c22,0xc3010a99,3
+np.float32,0x7f69af63,0x42ffbca2,3
+np.float32,0x7ec7d228,0x42fd48fe,3
+np.float32,0xff800000,0xffc00000,3
+np.float32,0xdd7c5,0xc301357c,3
+np.float32,0x143f38,0xc300a90e,3
+np.float32,0x7e65c176,0x42fbb01b,3
+np.float32,0x2c1a9e,0xc2ff1307,3
+np.float32,0x7f6e9224,0x42ffcbeb,3
+np.float32,0x3d32ab39,0xc0909a77,3
+np.float32,0x3e150b42,0xc031f22b,3
+np.float32,0x1f84b4,0xc300059a,3
+np.float32,0x3f71ce21,0xbda88c2a,3
+np.float32,0x2625c4,0xc2ff7e33,3
+np.float32,0x3dd0b293,0xc052dcdc,3
+np.float32,0x625c11,0xc2fcc290,3
+np.float32,0x3f610297,0xbe3e9f24,3
+np.float32,0x7ebdd5e5,0x42fd2320,3
+np.float32,0x3e883458,0xbff486ff,3
+np.float32,0x782313,0xc2fc2ed4,3
+np.float32,0x7f39c843,0x42ff132f,3
+np.float32,0x7f326aa7,0x42fef54d,3
+np.float32,0x4d2c71,0xc2fd75be,3
+np.float32,0x3f55747c,0xbe86409e,3
+np.float32,0x7f7f0867,0x42fffd34,3
+np.float32,0x321316,0xc2feb53f,3
+np.float32,0x3e1b37ed,0xc02e32b0,3
+np.float32,0x80edf,0xc301fd54,3
+np.float32,0x3f0b08ad,0xbf617607,3
+np.float32,0x7f3f4174,0x42ff28a2,3
+np.float32,0x3d79306d,0xc0813eb0,3
+np.float32,0x3f5f657a,0xbe49413d,3
+np.float32,0x3f56c63a,0xbe81b376,3
+np.float32,0x7f667123,0x42ffb24f,3
+np.float32,0x3f71021b,0xbdb24d43,3
+np.float32,0x7f434ab1,0x42ff380f,3
+np.float32,0x3dcae496,0xc055779c,3
+np.float32,0x3f5a7d88,0xbe6a0f5b,3
+np.float32,0x3cdf5c32,0xc0a64bf5,3
+np.float32,0x3e56222c,0xc0107d11,3
+np.float32,0x561a3a,0xc2fd24df,3
+np.float32,0x7ddd953c,0x42f9955a,3
+np.float32,0x7e35d839,0x42fb035c,3
+np.float32,0x3ec1816c,0xbfb3aeb2,3
+np.float32,0x7c87cfcd,0x42f42bc2,3
+np.float32,0xd9cd,0xc3053baf,3
+np.float32,0x3f388234,0xbef1e5b7,3
+np.float32,0x3edfcaca,0xbf98d47b,3
+np.float32,0x3ef28852,0xbf89fac8,3
+np.float32,0x7f7525df,0x42ffe001,3
+np.float32,0x7f6c33ef,0x42ffc48c,3
+np.float32,0x3ea4a881,0xbfd17e61,3
+np.float32,0x3f3e379f,0xbedb63c6,3
+np.float32,0x3f0524c1,0xbf717301,3
+np.float32,0x3db3e7f0,0xc06091d3,3
+np.float32,0x800000,0xc2fc0000,3
+np.float32,0x3f2f2897,0xbf0c27ce,3
+np.float32,0x7eb1776d,0x42fcf15c,3
+np.float32,0x3f039018,0xbf75dc37,3
+np.float32,0x3c4055,0xc2fe2c96,3
+np.float32,0x3f603653,0xbe43dea5,3
+np.float32,0x7f700d24,0x42ffd07c,3
+np.float32,0x3f4741a3,0xbeb918dc,3
+np.float32,0x3f5fe959,0xbe45da2d,3
+np.float32,0x3f3e4401,0xbedb33b1,3
+np.float32,0x7f0705ff,0x42fe2775,3
+np.float32,0x3ea85662,0xbfcd69b0,3
+np.float32,0x3f15f49f,0xbf458829,3
+np.float32,0x3f17c50e,0xbf411728,3
+np.float32,0x3e483f60,0xc016add2,3
+np.float32,0x3f1ab9e5,0xbf39f71b,3
+np.float32,0x3de0b6fb,0xc04c08fe,3
+np.float32,0x7e671225,0x42fbb452,3
+np.float32,0x80800000,0xffc00000,3
+np.float32,0xe2df3,0xc3012c9d,3
+np.float32,0x3ede1e3c,0xbf9a3770,3
+np.float32,0x3df2ffde,0xc044cfec,3
+np.float32,0x3eed8da5,0xbf8dcf6c,3
+np.float32,0x3ead15c3,0xbfc846e1,3
+np.float32,0x7ef3750a,0x42fddae4,3
+np.float32,0x7e6ab7c0,0x42fbbfe4,3
+np.float32,0x7ea4bbe5,0x42fcba5d,3
+np.float32,0x3f227706,0xbf27f0a1,3
+np.float32,0x3ef39bfd,0xbf89295a,3
+np.float32,0x3f289a20,0xbf1a3edd,3
+np.float32,0x7f225f82,0x42feafb4,3
+np.float32,0x768963,0xc2fc38bc,3
+np.float32,0x3f493c00,0xbeb1ccfc,3
+np.float32,0x3f4e7249,0xbe9ee9a7,3
+np.float32,0x1d0c3a,0xc30023c0,3
+np.float32,0x7f3c5f78,0x42ff1d6a,3
+np.float32,0xff7fffff,0xffc00000,3
+np.float32,0x3ee7896a,0xbf928c2a,3
+np.float32,0x3e788479,0xc002bd2e,3
+np.float32,0x3ee4df17,0xbf94af84,3
+np.float32,0x5e06d7,0xc2fce3d7,3
+np.float32,0x3d7b2776,0xc080e1dc,3
+np.float32,0x3e3d39d3,0xc01be7fd,3
+np.float32,0x7c81dece,0x42f40ab7,3
+np.float32,0x3f7d2085,0xbc856255,3
+np.float32,0x7f7f6627,0x42fffe44,3
+np.float32,0x7f5f2e94,0x42ff9aaa,3
+np.float32,0x7f5835f2,0x42ff8339,3
+np.float32,0x3f6a0e32,0xbe046580,3
+np.float32,0x7e16f586,0x42fa79dd,3
+np.float32,0x3f04a2f2,0xbf72dbc5,3
+np.float32,0x3f35e334,0xbefc7740,3
+np.float32,0x3f0d056e,0xbf5c3824,3
+np.float32,0x7ebeb95e,0x42fd2693,3
+np.float32,0x3c6192,0xc2fe2aff,3
+np.float32,0x3e892b4f,0xbff33958,3
+np.float32,0x3f61d694,0xbe3931df,3
+np.float32,0x29d183,0xc2ff3a56,3
+np.float32,0x7f0b0598,0x42fe3d04,3
+np.float32,0x7f743b28,0x42ffdd3d,3
+np.float32,0x3a2ed6,0xc2fe4663,3
+np.float32,0x3e27403a,0xc0274de8,3
+np.float32,0x3f58ee78,0xbe74a349,3
+np.float32,0x3eaa4b,0xc2fe0f92,3
+np.float32,0x3ecb613b,0xbfaa7de8,3
+np.float32,0x7f637d81,0x42ffa8c9,3
+np.float32,0x3f026e96,0xbf790c73,3
+np.float32,0x386cdf,0xc2fe5d0c,3
+np.float32,0x35abd1,0xc2fe8202,3
+np.float32,0x3eac3cd1,0xbfc92ee8,3
+np.float32,0x3f567869,0xbe82bf47,3
+np.float32,0x3f65c643,0xbe1faae6,3
+np.float32,0x7f5422b9,0x42ff752b,3
+np.float32,0x7c26e9,0xc2fc168c,3
+np.float32,0x7eff5cfd,0x42fdfe29,3
+np.float32,0x3f728e7f,0xbd9f6142,3
+np.float32,0x3f10fd43,0xbf51f874,3
+np.float32,0x7e7ada08,0x42fbf0fe,3
+np.float32,0x3e82a611,0xbffc37be,3
+np.float32,0xbf800000,0xffc00000,3
+np.float32,0x3dbe2e12,0xc05b711c,3
+np.float32,0x7e768fa9,0x42fbe440,3
+np.float32,0x5e44e8,0xc2fce1f0,3
+np.float32,0x7f25071a,0x42febbae,3
+np.float32,0x3f54db5e,0xbe885339,3
+np.float32,0x3f0f2c26,0xbf56a0b8,3
+np.float32,0x22f9a7,0xc2ffbe55,3
+np.float32,0x7ed63dcb,0x42fd7c77,3
+np.float32,0x7ea4fae2,0x42fcbb78,3
+np.float32,0x3f1d7766,0xbf337b47,3
+np.float32,0x7f16d59f,0x42fe7941,3
+np.float32,0x3f3a1bb6,0xbeeb855c,3
+np.float32,0x3ef57128,0xbf87c709,3
+np.float32,0xb24ff,0xc3018591,3
+np.float32,0x3ef99e27,0xbf84a983,3
+np.float32,0x3eac2ccf,0xbfc94013,3
+np.float32,0x3e9d3e1e,0xbfda00dc,3
+np.float32,0x718213,0xc2fc58c1,3
+np.float32,0x7edbf509,0x42fd8fea,3
+np.float32,0x70c7f1,0xc2fc5d80,3
+np.float32,0x3f7012f5,0xbdbdc6cd,3
+np.float32,0x12cba,0xc304c487,3
+np.float32,0x7f5d445d,0x42ff944c,3
+np.float32,0x7f3e30bd,0x42ff2481,3
+np.float32,0x63b110,0xc2fcb8a0,3
+np.float32,0x3f39f728,0xbeec1680,3
+np.float32,0x3f5bea58,0xbe6074b1,3
+np.float32,0x3f350749,0xbefff679,3
+np.float32,0x3e91ab2c,0xbfe81f3e,3
+np.float32,0x7ec53fe0,0x42fd3f6d,3
+np.float32,0x3f6cbbdc,0xbde72c8e,3
+np.float32,0x3f4df49f,0xbea0abcf,3
+np.float32,0x3e9c9638,0xbfdac674,3
+np.float32,0x7f3b82ec,0x42ff1a07,3
+np.float32,0x7f612a09,0x42ffa132,3
+np.float32,0x7ea26650,0x42fcafd3,3
+np.float32,0x3a615138,0xc122f26d,3
+np.float32,0x3f1108bd,0xbf51db39,3
+np.float32,0x6f80f6,0xc2fc65ea,3
+np.float32,0x3f7cb578,0xbc98ecb1,3
+np.float32,0x7f54d31a,0x42ff7790,3
+np.float32,0x196868,0xc3005532,3
+np.float32,0x3f01ee0a,0xbf7a7925,3
+np.float32,0x3e184013,0xc02ffb11,3
+np.float32,0xadde3,0xc3018ee3,3
+np.float32,0x252a91,0xc2ff9173,3
+np.float32,0x3f0382c2,0xbf7601a9,3
+np.float32,0x6d818c,0xc2fc7345,3
+np.float32,0x3bfbfd,0xc2fe2fdd,3
+np.float32,0x7f3cad19,0x42ff1e9a,3
+np.float32,0x4169a7,0xc2fdefdf,3
+np.float32,0x3f615d96,0xbe3c4a2b,3
+np.float32,0x3f036480,0xbf7656ac,3
+np.float32,0x7f5fbda3,0x42ff9c83,3
+np.float32,0x3d202d,0xc2fe21f1,3
+np.float32,0x3d0f5e5d,0xc09ac3e9,3
+np.float32,0x3f0fff6e,0xbf548142,3
+np.float32,0x7f11ed32,0x42fe60d2,3
+np.float32,0x3e6f856b,0xc00624b6,3
+np.float32,0x7f7c4dd7,0x42fff542,3
+np.float32,0x3e76fb86,0xc0034fa0,3
+np.float32,0x3e8a0d6e,0xbff209e7,3
+np.float32,0x3eacad19,0xbfc8b6ad,3
+np.float32,0xa7776,0xc3019cbe,3
+np.float32,0x3dc84d74,0xc056a754,3
+np.float32,0x3efb8052,0xbf834626,3
+np.float32,0x3f0e55fc,0xbf58cacc,3
+np.float32,0x7e0e71e3,0x42fa4efb,3
+np.float32,0x3ed5a800,0xbfa1639c,3
+np.float32,0x3f33335b,0xbf03babf,3
+np.float32,0x38cad7,0xc2fe5842,3
+np.float32,0x3bc21256,0xc0ecc927,3
+np.float32,0x3f09522d,0xbf660a19,3
+np.float32,0xcbd5d,0xc3015428,3
+np.float32,0x492752,0xc2fd9d42,3
+np.float32,0x3f2b9b32,0xbf13b904,3
+np.float32,0x6544ac,0xc2fcad09,3
+np.float32,0x52eb12,0xc2fd40b5,3
+np.float32,0x3f66a7c0,0xbe1a03e8,3
+np.float32,0x7ab289,0xc2fc1f41,3
+np.float32,0x62af5e,0xc2fcc020,3
+np.float32,0x7f73e9cf,0x42ffdc46,3
+np.float32,0x3e5eca,0xc2fe130e,3
+np.float32,0x3e3a10f4,0xc01d7602,3
+np.float32,0x3f04db46,0xbf723f0d,3
+np.float32,0x18fc4a,0xc3005b63,3
+np.float32,0x525bcb,0xc2fd45b6,3
+np.float32,0x3f6b9108,0xbdf5c769,3
+np.float32,0x3e992e8c,0xbfded5c5,3
+np.float32,0x7efea647,0x42fdfc18,3
+np.float32,0x7e8371db,0x42fc139e,3
+np.float32,0x3f397cfb,0xbeedfc69,3
+np.float32,0x7e46d233,0x42fb454a,3
+np.float32,0x7d5281ad,0x42f76f79,3
+np.float32,0x7f4c1878,0x42ff58a1,3
+np.float32,0x3e96ca5e,0xbfe1bd97,3
+np.float32,0x6a2743,0xc2fc8a3d,3
+np.float32,0x7f688781,0x42ffb8f8,3
+np.float32,0x7814b7,0xc2fc2f2d,3
+np.float32,0x3f2ffdc9,0xbf0a6756,3
+np.float32,0x3f766fa8,0xbd60fe24,3
+np.float32,0x4dc64e,0xc2fd7003,3
+np.float32,0x3a296f,0xc2fe46a8,3
+np.float32,0x3f2af942,0xbf15162e,3
+np.float32,0x7f702c32,0x42ffd0dc,3
+np.float32,0x7e61e318,0x42fba390,3
+np.float32,0x7f7d3bdb,0x42fff7fa,3
+np.float32,0x3ee87f3f,0xbf91c881,3
+np.float32,0x2bbc28,0xc2ff193c,3
+np.float32,0x3e01f918,0xc03e966e,3
+np.float32,0x7f0b39f4,0x42fe3e1a,3
+np.float32,0x3eaa4d64,0xbfcb4516,3
+np.float32,0x3e53901e,0xc0119a88,3
+np.float32,0x603cb,0xc3026957,3
+np.float32,0x7e81f926,0x42fc0b4d,3
+np.float32,0x5dab7c,0xc2fce6a6,3
+np.float32,0x3f46fefd,0xbeba1018,3
+np.float32,0x648448,0xc2fcb28a,3
+np.float32,0x3ec49470,0xbfb0c58b,3
+np.float32,0x3e8a5393,0xbff1ac2b,3
+np.float32,0x3f27ccfc,0xbf1c014e,3
+np.float32,0x3ed886e6,0xbf9eeca8,3
+np.float32,0x7cfbe06e,0x42f5f401,3
+np.float32,0x3f5aa7ba,0xbe68f229,3
+np.float32,0x9500d,0xc301c7e3,3
+np.float32,0x3f4861,0xc2fe0853,3
+np.float32,0x3e5ae104,0xc00e76f5,3
+np.float32,0x71253a,0xc2fc5b1e,3
+np.float32,0xcf7b8,0xc3014d9c,3
+np.float32,0x7f7edd2d,0x42fffcb7,3
+np.float32,0x3e9039ee,0xbfe9f5ab,3
+np.float32,0x2fd54e,0xc2fed712,3
+np.float32,0x3f600752,0xbe45147a,3
+np.float32,0x3f4da8f6,0xbea1bb5c,3
+np.float32,0x3f2d34a9,0xbf104bd9,3
+np.float32,0x3e1e66dd,0xc02c52d2,3
+np.float32,0x798276,0xc2fc2670,3
+np.float32,0xd55e2,0xc3014347,3
+np.float32,0x80000001,0xffc00000,3
+np.float32,0x3e7a5ead,0xc0020da6,3
+np.float32,0x7ec4c744,0x42fd3da9,3
+np.float32,0x597e00,0xc2fd085a,3
+np.float32,0x3dff6bf4,0xc0403575,3
+np.float32,0x5d6f1a,0xc2fce883,3
+np.float32,0x7e21faff,0x42faadea,3
+np.float32,0x3e570fea,0xc01016c6,3
+np.float32,0x28e6b6,0xc2ff4ab7,3
+np.float32,0x7e77062d,0x42fbe5a3,3
+np.float32,0x74cac4,0xc2fc43b0,3
+np.float32,0x3f707273,0xbdb93078,3
+np.float32,0x228e96,0xc2ffc737,3
+np.float32,0x686ac1,0xc2fc966b,3
+np.float32,0x3d76400d,0xc081cae8,3
+np.float32,0x3e9f502f,0xbfd7966b,3
+np.float32,0x3f6bc656,0xbdf32b1f,3
+np.float32,0x3edb828b,0xbf9c65d4,3
+np.float32,0x6c6e56,0xc2fc7a8e,3
+np.float32,0x3f04552e,0xbf73b48f,3
+np.float32,0x3f39cb69,0xbeecc457,3
+np.float32,0x7f681c44,0x42ffb7a3,3
+np.float32,0x7f5b44ee,0x42ff8d99,3
+np.float32,0x3e71430a,0xc005798d,3
+np.float32,0x3edcfde3,0xbf9b27c6,3
+np.float32,0x3f616a5a,0xbe3bf67f,3
+np.float32,0x3f523936,0xbe918548,3
+np.float32,0x3f39ce3a,0xbeecb925,3
+np.float32,0x3eac589a,0xbfc91120,3
+np.float32,0x7efc8d3d,0x42fdf5fc,3
+np.float32,0x5704b0,0xc2fd1d0f,3
+np.float32,0x7e7972e9,0x42fbecda,3
+np.float32,0x3eb0811c,0xbfc4aa13,3
+np.float32,0x7f1efcbb,0x42fea023,3
+np.float32,0x3e0b9e32,0xc037fa6b,3
+np.float32,0x7eef6a48,0x42fdce87,3
+np.float32,0x3cc0a373,0xc0ad20c0,3
+np.float32,0x3f2a75bb,0xbf1632ba,3
+np.float32,0x0,0xff800000,3
+np.float32,0x7ecdb6f4,0x42fd5e77,3
+np.float32,0x7f2e2dfd,0x42fee38d,3
+np.float32,0x3ee17f6e,0xbf976d8c,3
+np.float32,0x3f51e7ee,0xbe92a319,3
+np.float32,0x3f06942f,0xbf6d7d3c,3
+np.float32,0x3f7ba528,0xbccac6f1,3
+np.float32,0x3f413787,0xbecfd513,3
+np.float32,0x3e085e48,0xc03a2716,3
+np.float32,0x7e4c5e0e,0x42fb599c,3
+np.float32,0x306f76,0xc2fecdd4,3
+np.float32,0x7f5c2203,0x42ff9081,3
+np.float32,0x3d5355b4,0xc088da05,3
+np.float32,0x9a2a,0xc305bb4f,3
+np.float32,0x3db93a1f,0xc05de0db,3
+np.float32,0x4e50c6,0xc2fd6ae4,3
+np.float32,0x7ec4afed,0x42fd3d51,3
+np.float32,0x3a8f27,0xc2fe41a0,3
+np.float32,0x7f213caf,0x42feaa84,3
+np.float32,0x7e7b5f00,0x42fbf286,3
+np.float32,0x7e367194,0x42fb05ca,3
+np.float32,0x7f56e6de,0x42ff7ebd,3
+np.float32,0x3ed7383e,0xbfa00aef,3
+np.float32,0x7e844752,0x42fc184a,3
+np.float32,0x15157,0xc3049a19,3
+np.float32,0x3f78cd92,0xbd28824a,3
+np.float32,0x7ecddb16,0x42fd5ef9,3
+np.float32,0x3e479f16,0xc016f7d8,3
+np.float32,0x3f5cb418,0xbe5b2bd3,3
+np.float32,0x7c0934cb,0x42f2334e,3
+np.float32,0x3ebe5505,0xbfb6bc69,3
+np.float32,0x3eb1335a,0xbfc3eff5,3
+np.float32,0x3f2488a3,0xbf234444,3
+np.float32,0x642906,0xc2fcb52a,3
+np.float32,0x3da635fa,0xc067e15a,3
+np.float32,0x7e0d80db,0x42fa4a15,3
+np.float32,0x4f0b9d,0xc2fd640a,3
+np.float32,0x7e083806,0x42fa2df8,3
+np.float32,0x7f77f8c6,0x42ffe877,3
+np.float32,0x3e7bb46a,0xc0018ff5,3
+np.float32,0x3f06eb2e,0xbf6c8eca,3
+np.float32,0x7eae8f7c,0x42fce52a,3
+np.float32,0x3de481a0,0xc04a7d7f,3
+np.float32,0x3eed4311,0xbf8e096f,3
+np.float32,0x3f7b0300,0xbce8903d,3
+np.float32,0x3811b,0xc30330dd,3
+np.float32,0x3eb6f8e1,0xbfbe04bc,3
+np.float32,0x3ec35210,0xbfb1f55a,3
+np.float32,0x3d386916,0xc08f24a5,3
+np.float32,0x3f1fa197,0xbf2e704d,3
+np.float32,0x7f2020a5,0x42fea56a,3
+np.float32,0x7e1ea53f,0x42fa9e8c,3
+np.float32,0x3f148903,0xbf490bf9,3
+np.float32,0x3f2f56a0,0xbf0bc6c9,3
+np.float32,0x7da9fc,0xc2fc0d9b,3
+np.float32,0x3d802134,0xc07fe810,3
+np.float32,0x3f6cb927,0xbde74e57,3
+np.float32,0x7e05b125,0x42fa2023,3
+np.float32,0x3f3307f9,0xbf041433,3
+np.float32,0x5666bf,0xc2fd2250,3
+np.float32,0x3f51c93b,0xbe930f28,3
+np.float32,0x3eb5dcfe,0xbfbf241e,3
+np.float32,0xb2773,0xc301853f,3
+np.float32,0x7f4dee96,0x42ff5f3f,3
+np.float32,0x3e3f5c33,0xc01adee1,3
+np.float32,0x3f2ed29a,0xbf0cdd4a,3
+np.float32,0x3e3c01ef,0xc01c80ab,3
+np.float32,0x3ec2236e,0xbfb31458,3
+np.float32,0x7e841dc4,0x42fc1761,3
+np.float32,0x3df2cd8e,0xc044e30c,3
+np.float32,0x3f010901,0xbf7d0670,3
+np.float32,0x3c05ceaa,0xc0ddf39b,3
+np.float32,0x3f517226,0xbe944206,3
+np.float32,0x3f23c83d,0xbf24f522,3
+np.float32,0x7fc9da,0xc2fc0139,3
+np.float32,0x7f1bde53,0x42fe9181,3
+np.float32,0x3ea3786c,0xbfd2d4a5,3
+np.float32,0x3e83a71b,0xbffacdd2,3
+np.float32,0x3f6f0d4f,0xbdca61d5,3
+np.float32,0x7f5ab613,0x42ff8bb7,3
+np.float32,0x3ab1ec,0xc2fe3fea,3
+np.float32,0x4fbf58,0xc2fd5d82,3
+np.float32,0x3dea141b,0xc0484403,3
+np.float32,0x7d86ad3b,0x42f8258f,3
+np.float32,0x7f345315,0x42fefd29,3
+np.float32,0x3f3752fe,0xbef6a780,3
+np.float32,0x64830d,0xc2fcb293,3
+np.float32,0x3d9dc1eb,0xc06cb32a,3
+np.float32,0x3f2f935a,0xbf0b46f6,3
+np.float32,0xb90a4,0xc30177e3,3
+np.float32,0x4111dd,0xc2fdf3c1,3
+np.float32,0x3d4cd078,0xc08a4c68,3
+np.float32,0x3e95c3f1,0xbfe30011,3
+np.float32,0x3ec9f356,0xbfabcb4e,3
+np.float32,0x1b90d5,0xc3003717,3
+np.float32,0xee70f,0xc3011a3e,3
+np.float32,0x7fa00000,0x7fe00000,3
+np.float32,0x3f74cdb6,0xbd8422af,3
+np.float32,0x3d9b56fe,0xc06e2037,3
+np.float32,0x3f1853df,0xbf3fbc40,3
+np.float32,0x7d86a011,0x42f82547,3
+np.float32,0x3dff9629,0xc0402634,3
+np.float32,0x46f8c9,0xc2fdb39f,3
+np.float32,0x3e9b410b,0xbfdc5a87,3
+np.float32,0x3f5aed42,0xbe671cac,3
+np.float32,0x3b739886,0xc101257f,3
+np.float64,0x3fe2f58d6565eb1b,0xbfe82a641138e19a,2
+np.float64,0x3fee7f0642fcfe0d,0xbfb1c702f6974932,2
+np.float64,0x25b71f244b6e5,0xc090030d3b3c5d2b,2
+np.float64,0x8c9cc8e1193b,0xc0900b752a678fa8,2
+np.float64,0x3fd329b5d326536c,0xbffbd607f6db945c,2
+np.float64,0x3fb5109b3a2a2136,0xc00cd36bd15dfb18,2
+np.float64,0x3fd5393ae12a7276,0xbff97a7e4a157154,2
+np.float64,0x3fd374d1b926e9a3,0xbffb7c3e1a3a7ed3,2
+np.float64,0x3fe2c7f4e2658fea,0xbfe899f15ca78fcb,2
+np.float64,0x7fe3d6b81ee7ad6f,0x408ffa7b63d407ee,2
+np.float64,0x3fe086d097e10da1,0xbfee81456ce8dd03,2
+np.float64,0x7fd374a64ca6e94c,0x408ff241c7306d39,2
+np.float64,0x3fc0709a5b20e135,0xc007afdede31b29c,2
+np.float64,0x3fd4218f4b28431f,0xbffab2c696966e2d,2
+np.float64,0x143134c828628,0xc09006a8372c4d8a,2
+np.float64,0x3f8bd0aa0037a154,0xc018cf0e8b9c3107,2
+np.float64,0x7fe0ce905ee19d20,0x408ff8915e71bd67,2
+np.float64,0x3fda0f5f32b41ebe,0xbff4bd5e0869e820,2
+np.float64,0x7fe9ae63d0b35cc7,0x408ffd760ca4f292,2
+np.float64,0x3fe75abd9eeeb57b,0xbfdd1476fc8b3089,2
+np.float64,0x786c3110f0d87,0xc08ff8b44cedbeea,2
+np.float64,0x22c5fe80458d,0xc09013853591c2f2,2
+np.float64,0x3fdc250797384a0f,0xbff2f6a02c961f0b,2
+np.float64,0x3fa2b367b02566cf,0xc013199238485054,2
+np.float64,0x3fd26a910ca4d522,0xbffcc0e2089b1c0c,2
+np.float64,0x8068d3b300d1b,0xc08ff7f690210aac,2
+np.float64,0x3fe663bfa9ecc77f,0xbfe07cd95a43a5ce,2
+np.float64,0x3fd0ddb07321bb61,0xbffec886665e895e,2
+np.float64,0x3f91c730b0238e61,0xc0176452badc8d22,2
+np.float64,0x4dd10d309ba22,0xc08ffdbe738b1d8d,2
+np.float64,0x7fe322afa4a6455e,0x408ffa10c038f9de,2
+np.float64,0x7fdf7f7c42befef8,0x408ff7d147ddaad5,2
+np.float64,0x7fd673f386ace7e6,0x408ff3e920d00eef,2
+np.float64,0x3feaebfcadb5d7f9,0xbfcfe8ec27083478,2
+np.float64,0x3fdc6dc23738db84,0xbff2bb46794f07b8,2
+np.float64,0xcd8819599b103,0xc08ff288c5b2cf0f,2
+np.float64,0xfda00e77fb402,0xc08ff01b895d2236,2
+np.float64,0x840b02ff08161,0xc08ff7a41e41114c,2
+np.float64,0x3fbdce3a383b9c74,0xc008d1e61903a289,2
+np.float64,0x3fd24ed3c4a49da8,0xbffce3c12136b6d3,2
+np.float64,0x3fe8d0834131a107,0xbfd77b194e7051d4,2
+np.float64,0x3fdd0cb11aba1962,0xbff23b9dbd554455,2
+np.float64,0x1a32d97e3465c,0xc090052781a37271,2
+np.float64,0x3fdb09d2b1b613a5,0xbff3e396b862bd83,2
+np.float64,0x3fe04c848aa09909,0xbfef2540dd90103a,2
+np.float64,0x3fce0c48613c1891,0xc000b9f76877d744,2
+np.float64,0x3fc37109a226e213,0xc005c05d8b2b9a2f,2
+np.float64,0x81cf3837039e7,0xc08ff7d686517dff,2
+np.float64,0xd9342c29b2686,0xc08ff1e591c9a895,2
+np.float64,0x7fec731b0638e635,0x408ffea4884550a9,2
+np.float64,0x3fba0fc138341f82,0xc00a5e839b085f64,2
+np.float64,0x7fdda893b03b5126,0x408ff71f7c5a2797,2
+np.float64,0xd2a4bb03a5498,0xc08ff2402f7a907c,2
+np.float64,0x3fea61fb0d34c3f6,0xbfd1d293fbe76183,2
+np.float64,0x3fed5cf486fab9e9,0xbfbfc2e01a7ffff1,2
+np.float64,0x3fcbabc2bf375785,0xc001ad7750c9dbdf,2
+np.float64,0x3fdb5fff53b6bfff,0xbff39a7973a0c6a5,2
+np.float64,0x7feef05a00bde0b3,0x408fff9c5cbc8651,2
+np.float64,0xb1cf24f1639e5,0xc08ff434de10fffb,2
+np.float64,0x3fa583989c2b0731,0xc0124a8a3bbf18ce,2
+np.float64,0x7feae90bf9f5d217,0x408ffe002e7bbbea,2
+np.float64,0x3fe9ef41c4b3de84,0xbfd367878ae4528e,2
+np.float64,0x9be24ce337c4a,0xc08ff5b9b1c31cf9,2
+np.float64,0x3fe916894cb22d13,0xbfd677f915d58503,2
+np.float64,0x3fec1bab20f83756,0xbfc7f2777aabe8ee,2
+np.float64,0x3feaabf2873557e5,0xbfd0d11f28341233,2
+np.float64,0x3fd4d3c3b529a787,0xbff9e9e47acc8ca9,2
+np.float64,0x3fe4cfe96c699fd3,0xbfe3dc53fa739169,2
+np.float64,0xccfdb97399fb7,0xc08ff2908d893400,2
+np.float64,0x3fec7598be78eb31,0xbfc5a750f8f3441a,2
+np.float64,0x355be5fc6ab7e,0xc090010ca315b50b,2
+np.float64,0x3fba9f9074353f21,0xc00a1f80eaf5e581,2
+np.float64,0x7fdcaff189395fe2,0x408ff6bd1c5b90d9,2
+np.float64,0x3fd94d3b64b29a77,0xbff56be1b43d25f3,2
+np.float64,0x4e5f29949cbe6,0xc08ffda972da1d73,2
+np.float64,0x3fe654e2d9aca9c6,0xbfe09b88dcd8f15d,2
+np.float64,0x7fdc130190b82602,0x408ff67d496c1a27,2
+np.float64,0x3fbcd4701e39a8e0,0xc009343e36627e80,2
+np.float64,0x7fdaa4d38f3549a6,0x408ff5e2c6d8678f,2
+np.float64,0x3febe95e5237d2bd,0xbfc93e16d453fe3a,2
+np.float64,0x9ef5ca553deba,0xc08ff57ff4f7883d,2
+np.float64,0x7fe878e91170f1d1,0x408ffce795868fc8,2
+np.float64,0x3fe63dff466c7bff,0xbfe0caf2b79c9e5f,2
+np.float64,0x6561446ccac29,0xc08ffab0e383834c,2
+np.float64,0x30c6c2ae618d9,0xc09001914b30381b,2
+np.float64,0x7ff0000000000000,0x7ff0000000000000,2
+np.float64,0x3fe5c9daf1ab93b6,0xbfe1be81baf4dbdb,2
+np.float64,0x3fe0a03e24a1407c,0xbfee3a73c4c0e8f8,2
+np.float64,0xff2a2cf3fe546,0xc08ff009a7e6e782,2
+np.float64,0x7fcf0332213e0663,0x408fefa36235e210,2
+np.float64,0x3fb612affc2c2560,0xc00c494be9c8c33b,2
+np.float64,0x3fd2b259702564b3,0xbffc67967f077e75,2
+np.float64,0x7fcb63685d36c6d0,0x408fee343343f913,2
+np.float64,0x3fe369f1d5a6d3e4,0xbfe71251139939ad,2
+np.float64,0x3fdd17c618ba2f8c,0xbff232d11c986251,2
+np.float64,0x3f92cc8040259901,0xc01711d8e06b52ee,2
+np.float64,0x69a81dc2d3504,0xc08ffa36cdaf1141,2
+np.float64,0x3fea0fad99b41f5b,0xbfd2f4625a652645,2
+np.float64,0xd1cd5799a39ab,0xc08ff24c02b90d26,2
+np.float64,0x324e59ce649cc,0xc0900163ad091c76,2
+np.float64,0x3fc3d460a227a8c1,0xc00585f903dc7a7f,2
+np.float64,0xa7185ec74e30c,0xc08ff4ec7d65ccd9,2
+np.float64,0x3fa254eaac24a9d5,0xc01337053963321a,2
+np.float64,0x3feaeb112435d622,0xbfcfef3be17f81f6,2
+np.float64,0x60144c3ac028a,0xc08ffb4f8eb94595,2
+np.float64,0x7fa4d2ec6829a5d8,0x408fdb0a9670ab83,2
+np.float64,0x3fed1372f97a26e6,0xbfc1b1fe50d48a55,2
+np.float64,0x3fd5ade5972b5bcb,0xbff8fcf28f525031,2
+np.float64,0x7fe72e335bee5c66,0x408ffc4759236437,2
+np.float64,0x7fdfafab143f5f55,0x408ff7e2e22a8129,2
+np.float64,0x3fe90d0db9321a1b,0xbfd69ae5fe10eb9e,2
+np.float64,0x7fe20a59072414b1,0x408ff962a2492484,2
+np.float64,0x3fed853690bb0a6d,0xbfbdc9dc5f199d2b,2
+np.float64,0x3fd709d469ae13a9,0xbff795a218deb700,2
+np.float64,0x3fe21c35f5e4386c,0xbfea47d71789329b,2
+np.float64,0x9ea5ec053d4be,0xc08ff585c2f6b7a3,2
+np.float64,0x3fc0580f9e20b01f,0xc007c1268f49d037,2
+np.float64,0xd99127abb3225,0xc08ff1e0a1ff339d,2
+np.float64,0x3fdc8c9bbfb91937,0xbff2a2478354effb,2
+np.float64,0x3fe15fc6b162bf8d,0xbfec323ac358e008,2
+np.float64,0xffefffffffffffff,0x7ff8000000000000,2
+np.float64,0x3fee341afb3c6836,0xbfb556b6faee9a84,2
+np.float64,0x3fe4b64c56296c99,0xbfe4154835ad2afe,2
+np.float64,0x85de22810bbc5,0xc08ff77b914fe5b5,2
+np.float64,0x3fd22c72e3a458e6,0xbffd0f4269d20bb9,2
+np.float64,0xc090e5218123,0xc09009a4a65a8a8f,2
+np.float64,0x7fd9641692b2c82c,0x408ff5547782bdfc,2
+np.float64,0x3fd9b9cb28b37396,0xbff509a8fb59a9f1,2
+np.float64,0x3fcd2726f93a4e4e,0xc001135059a22117,2
+np.float64,0x3fa4b493d4296928,0xc0128323c7a55f4a,2
+np.float64,0x47455e788e8ac,0xc08ffec2101c1e82,2
+np.float64,0x3fe0d7e2e261afc6,0xbfeda0f1e2d0f4bd,2
+np.float64,0x3fe860fc5b70c1f9,0xbfd91dc42eaf72c2,2
+np.float64,0xa5d7805b4baf0,0xc08ff502bc819ff6,2
+np.float64,0xd83395b1b0673,0xc08ff1f33c3f94c2,2
+np.float64,0x3f865972e02cb2e6,0xc01a1243651565c8,2
+np.float64,0x52fc6952a5f8e,0xc08ffd006b158179,2
+np.float64,0x7fecac6c793958d8,0x408ffebbb1c09a70,2
+np.float64,0x7fe621ff606c43fe,0x408ffbbeb2b1473a,2
+np.float64,0x3fdb9f3f9db73e7f,0xbff365610c52bda7,2
+np.float64,0x7feab92992757252,0x408ffdeb92a04813,2
+np.float64,0xcc46c79f988d9,0xc08ff29adf03fb7c,2
+np.float64,0x3fe3156a03262ad4,0xbfe7dd0f598781c7,2
+np.float64,0x3fc00e3a61201c75,0xc007f5c121a87302,2
+np.float64,0x3fdce8e9f739d1d4,0xbff2581d41ef50ef,2
+np.float64,0x0,0xfff0000000000000,2
+np.float64,0x7d373ac4fa6e8,0xc08ff840fa8beaec,2
+np.float64,0x3fee41e0653c83c1,0xbfb4ae786f2a0d54,2
+np.float64,0x3ff0000000000000,0x0,2
+np.float64,0x7feca6fff9794dff,0x408ffeb982a70556,2
+np.float64,0x7fc532716d2a64e2,0x408feb3f0f6c095b,2
+np.float64,0x3fe4ec2954a9d853,0xbfe39dd44aa5a040,2
+np.float64,0x7fd3321d52a6643a,0x408ff21a0ab9cd85,2
+np.float64,0x7fd8f1b2dfb1e365,0x408ff52001fa7922,2
+np.float64,0x3fee5e58cabcbcb2,0xbfb3539734a24d8b,2
+np.float64,0x3feebf6e7dfd7edd,0xbfad7c648f025102,2
+np.float64,0x6008026ec0101,0xc08ffb5108b54a93,2
+np.float64,0x3fea06f5e2340dec,0xbfd3134a48283360,2
+np.float64,0x41cad13c8395b,0xc08fffae654b2426,2
+np.float64,0x7fedb5c9353b6b91,0x408fff249f1f32b6,2
+np.float64,0xe00c5af9c018c,0xc08ff189e68c655f,2
+np.float64,0x7feac398ddf58731,0x408ffdf01374de9f,2
+np.float64,0x3fed21127c7a4225,0xbfc15b8cf55628fa,2
+np.float64,0x3fd3446711a688ce,0xbffbb5f7252a9fa3,2
+np.float64,0x7fe75fa07a6ebf40,0x408ffc5fdb096018,2
+np.float64,0x3feeb1618cbd62c3,0xbfaece3bd0863070,2
+np.float64,0x7f5226e180244dc2,0x408fb174d506e52f,2
+np.float64,0x3fcd67deca3acfbe,0xc000f9cd7a490749,2
+np.float64,0xdc6f30efb8de6,0xc08ff1b9f2a22d2e,2
+np.float64,0x9c14931338293,0xc08ff5b5f975ec5d,2
+np.float64,0x7fe93e802df27cff,0x408ffd4354eba0e0,2
+np.float64,0x3feb92ae5077255d,0xbfcb7f2084e44dbb,2
+np.float64,0xd78dbfddaf1b8,0xc08ff1fc19fa5a13,2
+np.float64,0x7fe14c301fa2985f,0x408ff8e666cb6592,2
+np.float64,0xbda3d8b77b47b,0xc08ff37689f4b2e5,2
+np.float64,0x8a42953b14853,0xc08ff71c2db3b8cf,2
+np.float64,0x7fe4ca7e186994fb,0x408ffb05e94254a7,2
+np.float64,0x7fe92ffc5e325ff8,0x408ffd3cb0265b12,2
+np.float64,0x91b262912364d,0xc08ff681619be214,2
+np.float64,0x33fe2b0667fc6,0xc0900132f3fab55e,2
+np.float64,0x3fde10e9183c21d2,0xbff17060fb4416c7,2
+np.float64,0xb6b811cb6d702,0xc08ff3e46303b541,2
+np.float64,0x3fe4a7bda0a94f7b,0xbfe435c6481cd0e3,2
+np.float64,0x7fd9fe6057b3fcc0,0x408ff599c79a822c,2
+np.float64,0x3fef44bf917e897f,0xbfa11484e351a6e9,2
+np.float64,0x3fe57d701daafae0,0xbfe2618ab40fc01b,2
+np.float64,0x7fe52d2adbaa5a55,0x408ffb3c2fb1c99d,2
+np.float64,0xb432f66d6865f,0xc08ff40d6b4084fe,2
+np.float64,0xbff0000000000000,0x7ff8000000000000,2
+np.float64,0x7fecd2292bf9a451,0x408ffecad860de6f,2
+np.float64,0x3fddd2ae153ba55c,0xbff1a059adaca33e,2
+np.float64,0x3fee55d6e5bcabae,0xbfb3bb1c6179d820,2
+np.float64,0x7fc1d0085623a010,0x408fe93d16ada7a7,2
+np.float64,0x829b000105360,0xc08ff7c47629a68f,2
+np.float64,0x7fe1e0257523c04a,0x408ff94782cf0717,2
+np.float64,0x7fd652f9ad2ca5f2,0x408ff3d820ec892e,2
+np.float64,0x3fef2246203e448c,0xbfa444ab6209d8cd,2
+np.float64,0x3fec6c0ae178d816,0xbfc5e559ebd4e790,2
+np.float64,0x3fe6ddfee92dbbfe,0xbfdf06dd7d3fa7a8,2
+np.float64,0x3fb7fbcbea2ff798,0xc00b5404d859d148,2
+np.float64,0x7feb9a154d37342a,0x408ffe4b26c29e55,2
+np.float64,0x3fe4db717aa9b6e3,0xbfe3c2c6b3ef13bc,2
+np.float64,0x3fbae17dda35c2fc,0xc00a030f7f4b37e7,2
+np.float64,0x7fd632b9082c6571,0x408ff3c76826ef19,2
+np.float64,0x7fc4184a15283093,0x408feaa14adf00be,2
+np.float64,0x3fe052d19920a5a3,0xbfef136b5df81a3e,2
+np.float64,0x7fe38b872b67170d,0x408ffa4f51aafc86,2
+np.float64,0x3fef9842d03f3086,0xbf92d3d2a21d4be2,2
+np.float64,0x9cea662139d4d,0xc08ff5a634810daa,2
+np.float64,0x3fe35f0855e6be11,0xbfe72c4b564e62aa,2
+np.float64,0x3fecee3d3779dc7a,0xbfc29ee942f8729e,2
+np.float64,0x3fe7903fd72f2080,0xbfdc41db9b5f4048,2
+np.float64,0xb958889572b11,0xc08ff3ba366cf84b,2
+np.float64,0x3fcb3a67c53674d0,0xc001dd21081ad1ea,2
+np.float64,0xe3b1b53fc7637,0xc08ff15a3505e1ce,2
+np.float64,0xe5954ae9cb2aa,0xc08ff141cbbf0ae4,2
+np.float64,0x3fe394af74e7295f,0xbfe6ad1d13f206e8,2
+np.float64,0x7fe21dd704643bad,0x408ff96f13f80c1a,2
+np.float64,0x3fd23a7cf02474fa,0xbffcfd7454117a05,2
+np.float64,0x7fe257515e24aea2,0x408ff99378764d52,2
+np.float64,0x7fe4c5d0a6e98ba0,0x408ffb03503cf939,2
+np.float64,0x3fadc2c1603b8583,0xc0106b2c17550e3a,2
+np.float64,0x3fc0f7f02421efe0,0xc007525ac446864c,2
+np.float64,0x3feaf0b27275e165,0xbfcfc8a03eaa32ad,2
+np.float64,0x5ce7503cb9ceb,0xc08ffbb2de365fa8,2
+np.float64,0x2a0014f654003,0xc090026e41761a0d,2
+np.float64,0x7fe2c848a8e59090,0x408ff9d9b723ee89,2
+np.float64,0x7f66f54bc02dea97,0x408fbc2ae0ec5623,2
+np.float64,0xa35a890146b6,0xc0900a97b358ddbd,2
+np.float64,0x7fee267ded7c4cfb,0x408fff501560c9f5,2
+np.float64,0x3fe07c328520f865,0xbfee9ef7c3435b58,2
+np.float64,0x3fe67122cf6ce246,0xbfe06147001932ba,2
+np.float64,0x3fdacc8925359912,0xbff41824cece219e,2
+np.float64,0xffa3047fff461,0xc08ff00431ec9be3,2
+np.float64,0x3e1af43e7c35f,0xc090002c6573d29b,2
+np.float64,0x86fa94590df53,0xc08ff7632525ed92,2
+np.float64,0x7fec4c76227898eb,0x408ffe94d032c657,2
+np.float64,0x7fe2274ce1e44e99,0x408ff975194cfdff,2
+np.float64,0x7fe670e1b4ace1c2,0x408ffbe78cc451de,2
+np.float64,0x7fe853871db0a70d,0x408ffcd5e6a6ff47,2
+np.float64,0x3fcbf265db37e4cc,0xc0019026336e1176,2
+np.float64,0x3fef033cef3e067a,0xbfa726712eaae7f0,2
+np.float64,0x5d74973abae94,0xc08ffba15e6bb992,2
+np.float64,0x7fdd9c99b6bb3932,0x408ff71ad24a7ae0,2
+np.float64,0xbdc8e09b7b91c,0xc08ff3744939e9a3,2
+np.float64,0xdbfcff71b7fa0,0xc08ff1bfeecc9dfb,2
+np.float64,0xf9b38cf5f3672,0xc08ff0499af34a43,2
+np.float64,0x3fea820aa6b50415,0xbfd162a38e1927b1,2
+np.float64,0x3fe67f59a12cfeb3,0xbfe04412adca49dc,2
+np.float64,0x3feb301d9c76603b,0xbfce17e6edeb92d5,2
+np.float64,0x828ce00b0519c,0xc08ff7c5b5c57cde,2
+np.float64,0x4f935e229f26c,0xc08ffd7c67c1c54f,2
+np.float64,0x7fcd139e023a273b,0x408feee4f12ff11e,2
+np.float64,0x666a9944ccd54,0xc08ffa92d5e5cd64,2
+np.float64,0x3fe792f0fa6f25e2,0xbfdc374fda28f470,2
+np.float64,0xe996029bd32c1,0xc08ff10eb9b47a11,2
+np.float64,0x3fe7b0dd1eef61ba,0xbfdbc2676dc77db0,2
+np.float64,0x7fd3ec0127a7d801,0x408ff287bf47e27d,2
+np.float64,0x3fe793a8ea6f2752,0xbfdc347f7717e48d,2
+np.float64,0x7fdb89d15e3713a2,0x408ff64457a13ea2,2
+np.float64,0x3fe35b3cbbe6b679,0xbfe73557c8321b70,2
+np.float64,0x66573c94ccae8,0xc08ffa9504af7eb5,2
+np.float64,0x3fc620a2302c4144,0xc00442036b944a67,2
+np.float64,0x49b2fe0693660,0xc08ffe5f131c3c7e,2
+np.float64,0x7fda936cdfb526d9,0x408ff5db3ab3f701,2
+np.float64,0xc774ceef8ee9a,0xc08ff2e16d082fa1,2
+np.float64,0x4da9f8a09b55,0xc0900ee2206d0c88,2
+np.float64,0x3fe2ca5d5ae594bb,0xbfe89406611a5f1a,2
+np.float64,0x7fe0832497e10648,0x408ff85d1de6056e,2
+np.float64,0x3fe6a9e3222d53c6,0xbfdfda35a9bc2de1,2
+np.float64,0x3fed3d92c8ba7b26,0xbfc0a73620db8b98,2
+np.float64,0x3fdd2ec093ba5d81,0xbff2209cf78ce3f1,2
+np.float64,0x62fcb968c5f98,0xc08ffaf775a593c7,2
+np.float64,0xfcfb019ff9f60,0xc08ff0230e95bd16,2
+np.float64,0x3fd7a63e8f2f4c7d,0xbff6faf4fff7dbe0,2
+np.float64,0x3fef23b0ec3e4762,0xbfa4230cb176f917,2
+np.float64,0x340d1e6a681a5,0xc09001314b68a0a2,2
+np.float64,0x7fc0b85ba02170b6,0x408fe8821487b802,2
+np.float64,0x7fe9976e84f32edc,0x408ffd6bb6aaf467,2
+np.float64,0x329a0e9e65343,0xc090015b044e3270,2
+np.float64,0x3fea4928d3f49252,0xbfd2299b05546eab,2
+np.float64,0x3f188c70003118e0,0xc02ac3ce23bc5d5a,2
+np.float64,0x3fecce5020b99ca0,0xbfc36b23153d5f50,2
+np.float64,0x3fe203873e24070e,0xbfea86edb3690830,2
+np.float64,0x3fe02d9eaa205b3d,0xbfef7d18c54a76d2,2
+np.float64,0xef7537ebdeea7,0xc08ff0c55e9d89e7,2
+np.float64,0x3fedf7572efbeeae,0xbfb840af357cf07c,2
+np.float64,0xd1a97a61a354,0xc0900926fdfb96cc,2
+np.float64,0x7fe6a0daeced41b5,0x408ffc001edf1407,2
+np.float64,0x3fe5063625aa0c6c,0xbfe3647cfb949d62,2
+np.float64,0x7fe9b28d31736519,0x408ffd77eb4a922b,2
+np.float64,0x7feea90d033d5219,0x408fff81a4bbff62,2
+np.float64,0x3fe9494d17f2929a,0xbfd5bde02eb5287a,2
+np.float64,0x7feee17a8cbdc2f4,0x408fff96cf0dc16a,2
+np.float64,0xb2ad18ef655a3,0xc08ff4267eda8af8,2
+np.float64,0x3fad3b52683a76a5,0xc01085ab75b797ce,2
+np.float64,0x2300a65846016,0xc090037b81ce9500,2
+np.float64,0x3feb1041f9b62084,0xbfcef0c87d8b3249,2
+np.float64,0x3fdd887d3e3b10fa,0xbff1da0e1ede6db2,2
+np.float64,0x3fd3e410eb27c822,0xbffaf9b5fc9cc8cc,2
+np.float64,0x3fe0aa53e3e154a8,0xbfee1e7b5c486578,2
+np.float64,0x7fe33e389aa67c70,0x408ffa214fe50961,2
+np.float64,0x3fd27e3a43a4fc75,0xbffca84a79e8adeb,2
+np.float64,0x3fb309e0082613c0,0xc00dfe407b77a508,2
+np.float64,0x7feaf2ed8cf5e5da,0x408ffe046a9d1ba9,2
+np.float64,0x1e76167a3cec4,0xc0900448cd35ec67,2
+np.float64,0x3fe0a18e1721431c,0xbfee36cf1165a0d4,2
+np.float64,0x3fa73b78c02e76f2,0xc011d9069823b172,2
+np.float64,0x3fef6d48287eda90,0xbf9ab2d08722c101,2
+np.float64,0x8fdf0da31fbe2,0xc08ff6a6a2accaa1,2
+np.float64,0x3fc3638db826c71b,0xc005c86191688826,2
+np.float64,0xaa9c09c555381,0xc08ff4aefe1d9473,2
+np.float64,0x7fccb0f4523961e8,0x408feebd84773f23,2
+np.float64,0xede75dcfdbcec,0xc08ff0d89ba887d1,2
+np.float64,0x7f8a051520340a29,0x408fcd9cc17f0d95,2
+np.float64,0x3fef5ca2babeb945,0xbf9dc221f3618e6a,2
+np.float64,0x7fea0ff4bcf41fe8,0x408ffda193359f22,2
+np.float64,0x7fe05c53fd20b8a7,0x408ff841dc7123e8,2
+np.float64,0x3fc625664b2c4acd,0xc0043f8749b9a1d8,2
+np.float64,0x7fed58f98f7ab1f2,0x408fff00585f48c2,2
+np.float64,0x3fb3e5e51427cbca,0xc00d7bcb6528cafe,2
+np.float64,0x3fe728bd3d6e517a,0xbfdddafa72bd0f60,2
+np.float64,0x3fe3f005dd27e00c,0xbfe5d7b3ec93bca0,2
+np.float64,0x3fd74fbd1a2e9f7a,0xbff750001b63ce81,2
+np.float64,0x3fd3af6d85a75edb,0xbffb371d678d11b4,2
+np.float64,0x7fa690ad8c2d215a,0x408fdbf7db9c7640,2
+np.float64,0x3fbdfd38e23bfa72,0xc008bfc1c5c9b89e,2
+np.float64,0x3fe2374684a46e8d,0xbfea030c4595dfba,2
+np.float64,0x7fc0806c372100d7,0x408fe85b36fee334,2
+np.float64,0x3fef3ac47b7e7589,0xbfa2007195c5213f,2
+np.float64,0x3fb55473922aa8e7,0xc00cae7af8230e0c,2
+np.float64,0x7fe018dc152031b7,0x408ff811e0d712fa,2
+np.float64,0x3fe3b3fca56767f9,0xbfe6638ae2c99c62,2
+np.float64,0x7fac79818c38f302,0x408fdea720b39c3c,2
+np.float64,0x7fefffffffffffff,0x4090000000000000,2
+np.float64,0xd2b290cba5652,0xc08ff23f6d7152a6,2
+np.float64,0x7fc5848eb52b091c,0x408feb6b6f8b77d0,2
+np.float64,0xf399f62de733f,0xc08ff092ae319ad8,2
+np.float64,0x7fdec56c12bd8ad7,0x408ff78c4ddbc667,2
+np.float64,0x3fca640f1e34c81e,0xc0023969c5cbfa4c,2
+np.float64,0x3fd55225db2aa44c,0xbff95f7442a2189e,2
+np.float64,0x7fefa009a97f4012,0x408fffdd2f42ef9f,2
+np.float64,0x4a3b70609478,0xc0900f24e449bc3d,2
+np.float64,0x7fe3738b1ba6e715,0x408ffa411f2cb5e7,2
+np.float64,0x7fe5e53f0b6bca7d,0x408ffb9ed8d95cea,2
+np.float64,0x3fe274dd24a4e9ba,0xbfe967fb114b2a83,2
+np.float64,0x3fcbc58b8c378b17,0xc001a2bb1e158bcc,2
+np.float64,0x3fefc2c0043f8580,0xbf862c9b464dcf38,2
+np.float64,0xc2c4fafd858a0,0xc08ff327aecc409b,2
+np.float64,0x3fd8bc39a9b17873,0xbff5f1ad46e5a51c,2
+np.float64,0x3fdf341656be682d,0xbff094f41e7cb4c4,2
+np.float64,0x3fef8495c13f092c,0xbf966cf6313bae4c,2
+np.float64,0x3fe14e0f05229c1e,0xbfec6166f26b7161,2
+np.float64,0x3fed42d3b2ba85a7,0xbfc0860b773d35d8,2
+np.float64,0x7fd92bbac5b25775,0x408ff53abcb3fe0c,2
+np.float64,0xb1635b6f62c6c,0xc08ff43bdf47accf,2
+np.float64,0x4a3a2dbc94746,0xc08ffe49fabddb36,2
+np.float64,0x87d831290fb06,0xc08ff750419dc6fb,2
+np.float64,0x3fec4713f7f88e28,0xbfc6d6217c9f5cf9,2
+np.float64,0x7fed43ba2d3a8773,0x408ffef7fa2fc303,2
+np.float64,0x7fd1ec5b56a3d8b6,0x408ff14f62615f1e,2
+np.float64,0x3fee534b6c7ca697,0xbfb3da1951aa3e68,2
+np.float64,0x3febb564c2b76aca,0xbfca9737062e55e7,2
+np.float64,0x943e6b0f287ce,0xc08ff64e2d09335c,2
+np.float64,0xf177d957e2efb,0xc08ff0acab2999fa,2
+np.float64,0x7fb5b881a82b7102,0x408fe3872b4fde5e,2
+np.float64,0x3fdb2b4a97b65695,0xbff3c715c91359bc,2
+np.float64,0x3fac0a17e4381430,0xc010c330967309fb,2
+np.float64,0x7fd8057990b00af2,0x408ff4b0a287a348,2
+np.float64,0x1f9026a23f206,0xc09004144f3a19dd,2
+np.float64,0x3fdb2977243652ee,0xbff3c8a2fd05803d,2
+np.float64,0x3fe0f6e74b21edcf,0xbfed4c3bb956bae0,2
+np.float64,0xde9cc3bbbd399,0xc08ff19ce5c1e762,2
+np.float64,0x3fe72ce106ae59c2,0xbfddca7ab14ceba2,2
+np.float64,0x3fa8ee14e031dc2a,0xc01170d54ca88e86,2
+np.float64,0x3fe0b09bbb216137,0xbfee0d189a95b877,2
+np.float64,0x7fdfdcb157bfb962,0x408ff7f33cf2afea,2
+np.float64,0x3fef84d5f53f09ac,0xbf966134e2a154f4,2
+np.float64,0x3fea0e0b1bb41c16,0xbfd2fa2d36637d19,2
+np.float64,0x1ab76fd6356ef,0xc090050a9616ffbd,2
+np.float64,0x7fd0ccf79a2199ee,0x408ff09045af2dee,2
+np.float64,0x7fea929345f52526,0x408ffddadc322b07,2
+np.float64,0x3fe9ef629cf3dec5,0xbfd367129c166838,2
+np.float64,0x3feedf0ea2fdbe1d,0xbfaa862afca44c00,2
+np.float64,0x7fce725f723ce4be,0x408fef6cfd2769a8,2
+np.float64,0x7fe4313b3ca86275,0x408ffaaf9557ef8c,2
+np.float64,0xe2d46463c5a8d,0xc08ff165725c6b08,2
+np.float64,0x7fbacb4ace359695,0x408fe5f3647bd0d5,2
+np.float64,0x3fbafd009635fa01,0xc009f745a7a5c5d5,2
+np.float64,0x3fe3cea66ce79d4d,0xbfe6253b895e2838,2
+np.float64,0x7feaa71484354e28,0x408ffde3c0bad2a6,2
+np.float64,0x3fd755b8b42eab71,0xbff74a1444c6e654,2
+np.float64,0x3fc313e2172627c4,0xc005f830e77940c3,2
+np.float64,0x12d699a225ad4,0xc090070ec00f2338,2
+np.float64,0x3fa975fe8432ebfd,0xc01151b3da48b3f9,2
+np.float64,0x7fdce3103b39c61f,0x408ff6d19b3326fa,2
+np.float64,0x7fd341cbba268396,0x408ff2237490fdca,2
+np.float64,0x3fd8405885b080b1,0xbff6666d8802a7d5,2
+np.float64,0x3fe0f0cca3a1e199,0xbfed5cdb3e600791,2
+np.float64,0x7fbd56680c3aaccf,0x408fe6ff55bf378d,2
+np.float64,0x3f939c4f3027389e,0xc016d364dd6313fb,2
+np.float64,0x3fe9e87fac73d0ff,0xbfd37f9a2be4fe38,2
+np.float64,0x7fc93c6a883278d4,0x408fed4260e614f1,2
+np.float64,0x7fa88c0ff031181f,0x408fdcf09a46bd3a,2
+np.float64,0xd5487f99aa910,0xc08ff21b6390ab3b,2
+np.float64,0x3fe34acc96e69599,0xbfe75c9d290428fb,2
+np.float64,0x3fd17f5964a2feb3,0xbffdef50b524137b,2
+np.float64,0xe23dec0dc47be,0xc08ff16d1ce61dcb,2
+np.float64,0x3fec8bd64fb917ad,0xbfc5173941614b8f,2
+np.float64,0x3fc81d97d7303b30,0xc00343ccb791401d,2
+np.float64,0x7fe79ad18e2f35a2,0x408ffc7cf0ab0f2a,2
+np.float64,0x3f96306b402c60d7,0xc0161ce54754cac1,2
+np.float64,0xfb09fc97f6140,0xc08ff039d1d30123,2
+np.float64,0x3fec9c4afa793896,0xbfc4ace43ee46079,2
+np.float64,0x3f9262dac824c5b6,0xc01732a3a7eeb598,2
+np.float64,0x3fa5cd33f42b9a68,0xc01236ed4d315a3a,2
+np.float64,0x3fe7bb336caf7667,0xbfdb9a268a82e267,2
+np.float64,0xc6c338f98d867,0xc08ff2ebb8475bbc,2
+np.float64,0x3fd50714482a0e29,0xbff9b14a9f84f2c2,2
+np.float64,0xfff0000000000000,0x7ff8000000000000,2
+np.float64,0x3fde2cd0f93c59a2,0xbff15afe35a43a37,2
+np.float64,0xf1719cb9e2e34,0xc08ff0acf77b06d3,2
+np.float64,0xfd3caaf9fa796,0xc08ff020101771bd,2
+np.float64,0x7f750d63a02a1ac6,0x408fc32ad0caa362,2
+np.float64,0x7fcc50f4e238a1e9,0x408fee96a5622f1a,2
+np.float64,0x421d1da0843a4,0xc08fff9ffe62d869,2
+np.float64,0x3fd9e17023b3c2e0,0xbff4e631d687ee8e,2
+np.float64,0x3fe4999a09693334,0xbfe4556b3734c215,2
+np.float64,0xd619ef03ac33e,0xc08ff21013c85529,2
+np.float64,0x3fc4da522229b4a4,0xc004f150b2c573aa,2
+np.float64,0x3feb04b053b60961,0xbfcf3fc9e00ebc40,2
+np.float64,0x3fbedec5ea3dbd8c,0xc0086a33dc22fab5,2
+np.float64,0x7fec3b217ab87642,0x408ffe8dbc8ca041,2
+np.float64,0xdb257d33b64b0,0xc08ff1cb42d3c182,2
+np.float64,0x7fa2d92ec025b25d,0x408fd9e414d11cb0,2
+np.float64,0x3fa425c550284b8b,0xc012ab7cbf83be12,2
+np.float64,0x10b4869021692,0xc09007c0487d648a,2
+np.float64,0x7f97918c902f2318,0x408fd47867806574,2
+np.float64,0x3fe4f91238e9f224,0xbfe38160b4e99919,2
+np.float64,0x3fc2b1af6125635f,0xc00634343bc58461,2
+np.float64,0x3fc2a98071255301,0xc0063942bc8301be,2
+np.float64,0x3fe4cfc585299f8b,0xbfe3dca39f114f34,2
+np.float64,0x3fd1ea75b3a3d4eb,0xbffd63acd02c5406,2
+np.float64,0x3fd6bf48492d7e91,0xbff7e0cd249f80f9,2
+np.float64,0x76643d36ecc88,0xc08ff8e68f13b38c,2
+np.float64,0x7feeabab3e7d5755,0x408fff82a0fd4501,2
+np.float64,0x46c0d4a68d81b,0xc08ffed79abaddc9,2
+np.float64,0x3fd088d57ca111ab,0xbfff3dd0ed7128ea,2
+np.float64,0x3fed25887cba4b11,0xbfc13f47639bd645,2
+np.float64,0x7fd90984b4b21308,0x408ff52b022c7fb4,2
+np.float64,0x3fe6ef31daadde64,0xbfdec185760cbf21,2
+np.float64,0x3fe48dbe83291b7d,0xbfe47005b99920bd,2
+np.float64,0x3fdce8422f39d084,0xbff258a33a96cc8e,2
+np.float64,0xb8ecdef771d9c,0xc08ff3c0eca61b10,2
+np.float64,0x3fe9bbf9a03377f3,0xbfd41ecfdcc336b9,2
+np.float64,0x7fe2565339a4aca5,0x408ff992d8851eaf,2
+np.float64,0x3fe1693e3822d27c,0xbfec1919da2ca697,2
+np.float64,0x3fd3680488a6d009,0xbffb8b7330275947,2
+np.float64,0x7fbe4f3d2c3c9e79,0x408fe75fa3f4e600,2
+np.float64,0x7fd4cfef3ca99fdd,0x408ff308ee3ab50f,2
+np.float64,0x3fd9c9a51cb3934a,0xbff4fb7440055ce6,2
+np.float64,0x3fe08a9640a1152d,0xbfee76bd1bfbf5c2,2
+np.float64,0x3fef012c41fe0259,0xbfa757a2da7f9707,2
+np.float64,0x3fee653fe2fcca80,0xbfb2ffae0c95025c,2
+np.float64,0x7fd0776933a0eed1,0x408ff054e7b43d41,2
+np.float64,0x4c94e5c09929d,0xc08ffdedb7f49e5e,2
+np.float64,0xca3e3d17947c8,0xc08ff2b86dce2f7a,2
+np.float64,0x3fb528e1342a51c2,0xc00cc626c8e2d9ba,2
+np.float64,0xd774df81aee9c,0xc08ff1fd6f0a7548,2
+np.float64,0x3fc47a9b6128f537,0xc00526c577b80849,2
+np.float64,0x3fe29a6f6a6534df,0xbfe90a5f83644911,2
+np.float64,0x3fecda4f59f9b49f,0xbfc31e4a80c4cbb6,2
+np.float64,0x7fe51d44f5aa3a89,0x408ffb3382437426,2
+np.float64,0x3fd677fc412ceff9,0xbff82999086977e7,2
+np.float64,0x3fe2a3c7e7254790,0xbfe8f33415cdba9d,2
+np.float64,0x3fe6d8d1dc6db1a4,0xbfdf1bc61bc24dff,2
+np.float64,0x7febb32d8ef7665a,0x408ffe55a043ded1,2
+np.float64,0x60677860c0d0,0xc0900da2caa7d571,2
+np.float64,0x7390c2e0e7219,0xc08ff92df18bb5d2,2
+np.float64,0x3fca53711b34a6e2,0xc00240b07a9b529b,2
+np.float64,0x7fe7ce6dd8ef9cdb,0x408ffc961164ead9,2
+np.float64,0x7fc0c9de0d2193bb,0x408fe88e245767f6,2
+np.float64,0xc0ee217981dc4,0xc08ff343b77ea770,2
+np.float64,0x72bd4668e57a9,0xc08ff94323fd74fc,2
+np.float64,0x7fd6970e252d2e1b,0x408ff3fb1e2fead2,2
+np.float64,0x7fdcb61040396c20,0x408ff6bf926bc98f,2
+np.float64,0xda4faa25b49f6,0xc08ff1d68b3877f0,2
+np.float64,0x3feb344749f6688f,0xbfcdfba2d66c72c5,2
+np.float64,0x3fe2aa4284e55485,0xbfe8e32ae0683f57,2
+np.float64,0x3f8e8fcfd03d1fa0,0xc01843efb2129908,2
+np.float64,0x8000000000000000,0xfff0000000000000,2
+np.float64,0x3fd8e01155b1c023,0xbff5d0529dae9515,2
+np.float64,0x3fe8033f3370067e,0xbfda837c80b87e7c,2
+np.float64,0x7fc5bf831e2b7f05,0x408feb8ae3b039a0,2
+np.float64,0x3fd8dcdf5331b9bf,0xbff5d349e1ed422a,2
+np.float64,0x3fe58b4e302b169c,0xbfe243c9cbccde44,2
+np.float64,0x3fea8a2e47b5145d,0xbfd1464e37221894,2
+np.float64,0x75cd1e88eb9a4,0xc08ff8f553ef0475,2
+np.float64,0x7fcfc876e23f90ed,0x408fefebe6cc95e6,2
+np.float64,0x7f51aceb002359d5,0x408fb1263f9003fb,2
+np.float64,0x7fc2a1b877254370,0x408fe9c1ec52f8b9,2
+np.float64,0x7fd495810e292b01,0x408ff2e859414d31,2
+np.float64,0x7fd72048632e4090,0x408ff440690cebdb,2
+np.float64,0x7fd7aafaffaf6,0xc08ff803a390779f,2
+np.float64,0x7fe18067d4a300cf,0x408ff9090a02693f,2
+np.float64,0x3fdc1080f8b82102,0xbff3077bf44a89bd,2
+np.float64,0x3fc34a462f26948c,0xc005d777b3cdf139,2
+np.float64,0x3fe21e4a1fe43c94,0xbfea428acfbc6ea9,2
+np.float64,0x1f0d79083e1b0,0xc090042c65a7abf2,2
+np.float64,0x3fe8d0d15931a1a3,0xbfd779f6bbd4db78,2
+np.float64,0x3fe74578022e8af0,0xbfdd68b6c15e9f5e,2
+np.float64,0x50995dd0a132c,0xc08ffd56a5c8accf,2
+np.float64,0x3f9a6342b034c685,0xc0151ce1973c62bd,2
+np.float64,0x3f30856a00210ad4,0xc027e852f4d1fcbc,2
+np.float64,0x3febcf7646b79eed,0xbfc9e9cc9d12425c,2
+np.float64,0x8010000000000000,0x7ff8000000000000,2
+np.float64,0x3fdf520c02bea418,0xbff07ed5013f3062,2
+np.float64,0x3fe5433ecbea867e,0xbfe2df38968b6d14,2
+np.float64,0x3fb933a84e326751,0xc00ac1a144ad26c5,2
+np.float64,0x7b6d72c2f6daf,0xc08ff86b7a67f962,2
+np.float64,0xaef5dae75debc,0xc08ff46496bb2932,2
+np.float64,0x522d869aa45b1,0xc08ffd1d55281e98,2
+np.float64,0xa2462b05448c6,0xc08ff542fe0ac5fd,2
+np.float64,0x3fe2b71dd6e56e3c,0xbfe8c3690cf15415,2
+np.float64,0x3fe5778231aaef04,0xbfe26e495d09b783,2
+np.float64,0x3fe9b8d564f371ab,0xbfd42a161132970d,2
+np.float64,0x3f89ebc34033d787,0xc019373f90bfc7f1,2
+np.float64,0x3fe438ddc6e871bc,0xbfe53039341b0a93,2
+np.float64,0x873c75250e78f,0xc08ff75d8478dccd,2
+np.float64,0x807134cb00e27,0xc08ff7f5cf59c57a,2
+np.float64,0x3fac459878388b31,0xc010b6fe803bcdc2,2
+np.float64,0xca9dc7eb953b9,0xc08ff2b2fb480784,2
+np.float64,0x7feb38587bb670b0,0x408ffe21ff6d521e,2
+np.float64,0x7fd70e9b782e1d36,0x408ff437936b393a,2
+np.float64,0x3fa4037bbc2806f7,0xc012b55744c65ab2,2
+np.float64,0x3fd3d4637427a8c7,0xbffb0beebf4311ef,2
+np.float64,0x7fdabbda5db577b4,0x408ff5ecbc0d4428,2
+np.float64,0x7fda9be0a2b537c0,0x408ff5dee5d03d5a,2
+np.float64,0x7fe9c74396338e86,0x408ffd813506a18a,2
+np.float64,0x3fd058243e20b048,0xbfff822ffd8a7f21,2
+np.float64,0x3fe6aa6ca9ed54d9,0xbfdfd805629ff49e,2
+np.float64,0x3fd91431d5322864,0xbff5a025eea8c78b,2
+np.float64,0x7fe4d7f02329afdf,0x408ffb0d5d9b7878,2
+np.float64,0x3fe2954a12252a94,0xbfe917266e3e22d5,2
+np.float64,0x3fb25f7c8224bef9,0xc00e6764c81b3718,2
+np.float64,0x3fda4bddeeb497bc,0xbff4880638908c81,2
+np.float64,0x55dfd12eabbfb,0xc08ffc9b54ff4002,2
+np.float64,0x3fe8f399e031e734,0xbfd6f8e5c4dcd93f,2
+np.float64,0x3fd954a24832a945,0xbff56521f4707a06,2
+np.float64,0x3fdea911f2bd5224,0xbff0fcb2d0c2b2e2,2
+np.float64,0x3fe6b4ff8a2d69ff,0xbfdfacfc85cafeab,2
+np.float64,0x3fc7fa02042ff404,0xc00354e13b0767ad,2
+np.float64,0x3fe955088c72aa11,0xbfd593130f29949e,2
+np.float64,0xd7e74ec1afcea,0xc08ff1f74f61721c,2
+np.float64,0x3fe9d69c1ab3ad38,0xbfd3bf710a337e06,2
+np.float64,0x3fd85669a2b0acd3,0xbff65176143ccc1e,2
+np.float64,0x3fea99b285353365,0xbfd11062744783f2,2
+np.float64,0x3fe2c79f80a58f3f,0xbfe89ac33f990289,2
+np.float64,0x3f8332ba30266574,0xc01af2cb7b635783,2
+np.float64,0x30d0150061a1,0xc090119030f74c5d,2
+np.float64,0x3fdbf4cb06b7e996,0xbff31e5207aaa754,2
+np.float64,0x3fe6b56c216d6ad8,0xbfdfab42fb2941c5,2
+np.float64,0x7fc4dc239829b846,0x408feb0fb0e13fbe,2
+np.float64,0x3fd0ab85ef21570c,0xbfff0d95d6c7a35c,2
+np.float64,0x7fe13d75e5e27aeb,0x408ff8dc8efa476b,2
+np.float64,0x3fece3b832f9c770,0xbfc2e21b165d583f,2
+np.float64,0x3fe3a279c4e744f4,0xbfe68ca4fbb55dbf,2
+np.float64,0x3feb64659ef6c8cb,0xbfccb6204b6bf724,2
+np.float64,0x2279a6bc44f36,0xc0900391eeeb3e7c,2
+np.float64,0xb88046d571009,0xc08ff3c7b5b45300,2
+np.float64,0x7ff4000000000000,0x7ffc000000000000,2
+np.float64,0x3fe49af059a935e1,0xbfe4526c294f248f,2
+np.float64,0xa3e5508147cc,0xc0900a92ce5924b1,2
+np.float64,0x7fc56def3d2adbdd,0x408feb5f46c360e8,2
+np.float64,0x7fd99f3574333e6a,0x408ff56f3807987c,2
+np.float64,0x3fdc38d56fb871ab,0xbff2e667cad8f36a,2
+np.float64,0xd0b03507a1607,0xc08ff25bbcf8aa9d,2
+np.float64,0xc493f9078927f,0xc08ff30c5fa4e759,2
+np.float64,0x3fc86ddbcb30dbb8,0xc0031da1fcb56d75,2
+np.float64,0x7fe75dc395aebb86,0x408ffc5eef841491,2
+np.float64,0x1647618a2c8ed,0xc0900616ef9479c1,2
+np.float64,0xdf144763be289,0xc08ff196b527f3c9,2
+np.float64,0x3fe0b29da6a1653b,0xbfee078b5f4d7744,2
+np.float64,0x3feb055852b60ab1,0xbfcf3b4db5779a7a,2
+np.float64,0x3fe8bc1625f1782c,0xbfd7c739ade904bc,2
+np.float64,0x7fd19bfb8ea337f6,0x408ff11b2b55699c,2
+np.float64,0x3fed1d80d1ba3b02,0xbfc1722e8d3ce094,2
+np.float64,0x2d9c65925b38e,0xc09001f46bcd3bc5,2
+np.float64,0x7fed6f4d857ade9a,0x408fff091cf6a3b4,2
+np.float64,0x3fd070cd6ba0e19b,0xbfff5f7609ca29e8,2
+np.float64,0x7fea3508b8f46a10,0x408ffdb1f30bd6be,2
+np.float64,0x508b897ca1172,0xc08ffd58a0eb3583,2
+np.float64,0x7feba367b07746ce,0x408ffe4f0bf4bd4e,2
+np.float64,0x3fefebd5c4bfd7ac,0xbf6d20b4fcf21b69,2
+np.float64,0x3fd8ef07b8b1de0f,0xbff5c2745c0795a5,2
+np.float64,0x3fd38ed518271daa,0xbffb5d75f00f6900,2
+np.float64,0x6de0fecedbc20,0xc08ff9c307bbc647,2
+np.float64,0xafc0ffc35f820,0xc08ff45737e5d6b4,2
+np.float64,0x7fd282097ca50412,0x408ff1ae3b27bf3b,2
+np.float64,0x3fe2f2d50b65e5aa,0xbfe831042e6a1e99,2
+np.float64,0x3faa437bac3486f7,0xc01123d8d962205a,2
+np.float64,0x3feea54434fd4a88,0xbfaff202cc456647,2
+np.float64,0x3fc9e65b8633ccb7,0xc00270e77ffd19da,2
+np.float64,0x7fee15af61fc2b5e,0x408fff49a49154a3,2
+np.float64,0x7fefe670a73fcce0,0x408ffff6c44c1005,2
+np.float64,0x3fc0832d0f21065a,0xc007a2dc2f25384a,2
+np.float64,0x3fecfc96bcb9f92d,0xbfc24367c3912620,2
+np.float64,0x3feb705682b6e0ad,0xbfcc65b1bb16f9c5,2
+np.float64,0x3fe185c4f9630b8a,0xbfebcdb401af67a4,2
+np.float64,0x3fb0a5a9f6214b54,0xc00f8ada2566a047,2
+np.float64,0x7fe2908cdda52119,0x408ff9b744861fb1,2
+np.float64,0x7fee776e183ceedb,0x408fff6ee7c2f86e,2
+np.float64,0x3fce1d608f3c3ac1,0xc000b3685d006474,2
+np.float64,0x7fecf92aa339f254,0x408ffeda6c998267,2
+np.float64,0xce13cb519c27a,0xc08ff280f02882a9,2
+np.float64,0x1,0xc090c80000000000,2
+np.float64,0x3fe485a8afa90b51,0xbfe4823265d5a50a,2
+np.float64,0x3feea60908bd4c12,0xbfafdf7ad7fe203f,2
+np.float64,0x3fd2253033a44a60,0xbffd187d0ec8d5b9,2
+np.float64,0x435338fc86a68,0xc08fff6a591059dd,2
+np.float64,0x7fce8763a73d0ec6,0x408fef74f1e715ff,2
+np.float64,0x3fbe5ddb783cbbb7,0xc0089acc5afa794b,2
+np.float64,0x7fe4cf19ada99e32,0x408ffb0877ca302b,2
+np.float64,0x3fe94c9ea1b2993d,0xbfd5b1c2e867b911,2
+np.float64,0x3fe75541c72eaa84,0xbfdd2a27aa117699,2
+np.float64,0x8000000000000001,0x7ff8000000000000,2
+np.float64,0x7fdbec7f2c37d8fd,0x408ff66d69a7f818,2
+np.float64,0x8ef10d091de22,0xc08ff6b9ca5094f8,2
+np.float64,0x3fea69025b74d205,0xbfd1b9fe2c252c70,2
+np.float64,0x562376d0ac46f,0xc08ffc924111cd31,2
+np.float64,0x8e8097ab1d013,0xc08ff6c2e2706f67,2
+np.float64,0x3fca6803ed34d008,0xc00237aef808825b,2
+np.float64,0x7fe8fe9067b1fd20,0x408ffd25f459a7d1,2
+np.float64,0x3f918e8c7f233,0xc0900009fe011d54,2
+np.float64,0x3fdfe773833fcee7,0xbff011bc1af87bb9,2
+np.float64,0xefffef6fdfffe,0xc08ff0beb0f09eb0,2
+np.float64,0x7fe64610282c8c1f,0x408ffbd17209db18,2
+np.float64,0xe66be8c1ccd7d,0xc08ff13706c056e1,2
+np.float64,0x2837e570506fd,0xc09002ae4dae0c1a,2
+np.float64,0x3febe3a081f7c741,0xbfc964171f2a5a47,2
+np.float64,0x3fe21ed09a243da1,0xbfea41342d29c3ff,2
+np.float64,0x3fe1596c8162b2d9,0xbfec431eee30823a,2
+np.float64,0x8f2b9a131e574,0xc08ff6b51104ed4e,2
+np.float64,0x3fe88ed179711da3,0xbfd870d08a4a4b0c,2
+np.float64,0x34159bc2682b4,0xc09001305a885f94,2
+np.float64,0x1ed31e543da65,0xc0900437481577f8,2
+np.float64,0x3feafbe9de75f7d4,0xbfcf7bcdbacf1c61,2
+np.float64,0xfb16fb27f62e0,0xc08ff03938e682a2,2
+np.float64,0x3fe5cd5ba7eb9ab7,0xbfe1b7165771af3c,2
+np.float64,0x7fe72905e76e520b,0x408ffc44c4e7e80c,2
+np.float64,0x7fb7136e2e2e26db,0x408fe439fd383fb7,2
+np.float64,0x8fa585e11f4c,0xc0900b55a08a486b,2
+np.float64,0x7fed985ce47b30b9,0x408fff192b596821,2
+np.float64,0x3feaaf0869755e11,0xbfd0c671571b3764,2
+np.float64,0x3fa40fd4ec281faa,0xc012b1c8dc0b9e5f,2
+np.float64,0x7fda2a70993454e0,0x408ff5ad47b0c68a,2
+np.float64,0x3fe5f7e931abefd2,0xbfe15d52b3605abf,2
+np.float64,0x3fe9fc6d3533f8da,0xbfd338b06a790994,2
+np.float64,0x3fe060649420c0c9,0xbfeeed1756111891,2
+np.float64,0x3fce8435e33d086c,0xc0008c41cea9ed40,2
+np.float64,0x7ff8000000000000,0x7ff8000000000000,2
+np.float64,0x617820aec2f05,0xc08ffb251e9af0f0,2
+np.float64,0x7fcc4ab6ee38956d,0x408fee9419c8f77d,2
+np.float64,0x7fdefda2fc3dfb45,0x408ff7a15063bc05,2
+np.float64,0x7fe5138ccaaa2719,0x408ffb2e30f3a46e,2
+np.float64,0x3fe3817a836702f5,0xbfe6da7c2b25e35a,2
+np.float64,0x3fb8a7dafa314fb6,0xc00b025bc0784ebe,2
+np.float64,0x349dc420693d,0xc09011215825d2c8,2
+np.float64,0x6b0e504ad61cb,0xc08ffa0fee9c5cd6,2
+np.float64,0x273987644e732,0xc09002d34294ed79,2
+np.float64,0x3fc0bd8a6e217b15,0xc0077a5828b4d2f5,2
+np.float64,0x758b48c4eb16a,0xc08ff8fbc8fbe46a,2
+np.float64,0x3fc8a9a52631534a,0xc00301854ec0ef81,2
+np.float64,0x7fe79d29a76f3a52,0x408ffc7e1607a4c1,2
+np.float64,0x3fd7d3ebce2fa7d8,0xbff6ce8a94aebcda,2
+np.float64,0x7fd1cb68a52396d0,0x408ff13a17533b2b,2
+np.float64,0x7fda514a5d34a294,0x408ff5be5e081578,2
+np.float64,0x3fc40b4382281687,0xc0056632c8067228,2
+np.float64,0x7feff1208c3fe240,0x408ffffaa180fa0d,2
+np.float64,0x8f58739f1eb0f,0xc08ff6b17402689d,2
+np.float64,0x1fdbe9a23fb7e,0xc090040685b2d24f,2
+np.float64,0xcb1d0e87963a2,0xc08ff2abbd903b82,2
+np.float64,0x3fc45a6a1a28b4d4,0xc00538f86c4aeaee,2
+np.float64,0x3fe61885b1ac310b,0xbfe118fd2251d2ec,2
+np.float64,0x3fedf584c8fbeb0a,0xbfb8572433ff67a9,2
+np.float64,0x7fb0bddd1a217bb9,0x408fe085e0d621db,2
+np.float64,0x72d8d3e0e5b3,0xc0900ca02f68c7a1,2
+np.float64,0x5cca6ff6b994f,0xc08ffbb6751fda01,2
+np.float64,0x7fe3197839a632ef,0x408ffa0b2fccfb68,2
+np.float64,0x3fcce4d9c139c9b4,0xc0012dae05baa91b,2
+np.float64,0x3fe76d00f62eda02,0xbfdccc5f12799be1,2
+np.float64,0x3fc53c22f72a7846,0xc004bbaa9cbc7958,2
+np.float64,0x7fdda02f1ebb405d,0x408ff71c37c71659,2
+np.float64,0x3fe0844eaba1089d,0xbfee884722762583,2
+np.float64,0x3febb438dc776872,0xbfca9f05e1c691f1,2
+np.float64,0x3fdf4170cdbe82e2,0xbff08b1561c8d848,2
+np.float64,0x3fce1b8d6f3c371b,0xc000b41b69507671,2
+np.float64,0x8370e60706e1d,0xc08ff7b19ea0b4ca,2
+np.float64,0x7fa5bf92382b7f23,0x408fdb8aebb3df87,2
+np.float64,0x7fe4a59979a94b32,0x408ffaf15c1358cd,2
+np.float64,0x3faa66086034cc11,0xc0111c466b7835d6,2
+np.float64,0x7fb7a958262f52af,0x408fe48408b1e093,2
+np.float64,0x3fdaacc5f635598c,0xbff43390d06b5614,2
+np.float64,0x3fd2825b9e2504b7,0xbffca3234264f109,2
+np.float64,0x3fcede160a3dbc2c,0xc0006a759e29060c,2
+np.float64,0x7fd3b19603a7632b,0x408ff265b528371c,2
+np.float64,0x7fcf8a86ea3f150d,0x408fefd552e7f3b2,2
+np.float64,0xedbcc0f7db798,0xc08ff0daad12096b,2
+np.float64,0xf1e1683de3c2d,0xc08ff0a7a0a37e00,2
+np.float64,0xb6ebd9bf6dd7b,0xc08ff3e11e28378d,2
+np.float64,0x3fec8090d6f90122,0xbfc56031b72194cc,2
+np.float64,0x3fd3e10e37a7c21c,0xbffafd34a3ebc933,2
+np.float64,0x7fbb1c96aa36392c,0x408fe616347b3342,2
+np.float64,0x3fe2f3996f25e733,0xbfe82f25bc5d1bbd,2
+np.float64,0x7fe8709da870e13a,0x408ffce3ab6ce59a,2
+np.float64,0x7fea3233d1b46467,0x408ffdb0b3bbc6de,2
+np.float64,0x65fa4112cbf49,0xc08ffa9f85eb72b9,2
+np.float64,0x3fca2cae9f34595d,0xc00251bb275afb87,2
+np.float64,0x8135fd9f026c0,0xc08ff7e42e14dce7,2
+np.float64,0x7fe0a6f057e14de0,0x408ff876081a4bfe,2
+np.float64,0x10000000000000,0xc08ff00000000000,2
+np.float64,0x3fe1fd506263faa1,0xbfea96dd8c543b72,2
+np.float64,0xa5532c554aa66,0xc08ff50bf5bfc66d,2
+np.float64,0xc239d00b8473a,0xc08ff32ff0ea3f92,2
+np.float64,0x7fdb5314e336a629,0x408ff62d4ff60d82,2
+np.float64,0x3fe5f506e2abea0e,0xbfe16362a4682120,2
+np.float64,0x3fa20c60202418c0,0xc0134e08d82608b6,2
+np.float64,0x7fe03864b22070c8,0x408ff82866d65e9a,2
+np.float64,0x3fe72cf5656e59eb,0xbfddca298969effa,2
+np.float64,0x5c295386b852b,0xc08ffbca90b136c9,2
+np.float64,0x7fd71e5020ae3c9f,0x408ff43f6d58eb7c,2
+np.float64,0x3fd1905a842320b5,0xbffdd8ecd288159c,2
+np.float64,0x3fe6bddb256d7bb6,0xbfdf88fee1a820bb,2
+np.float64,0xe061b967c0c37,0xc08ff18581951561,2
+np.float64,0x3fe534f65cea69ed,0xbfe2fe45fe7d3040,2
+np.float64,0xdc7dae07b8fb6,0xc08ff1b93074ea76,2
+np.float64,0x3fd0425082a084a1,0xbfffa11838b21633,2
+np.float64,0xba723fc974e48,0xc08ff3a8b8d01c58,2
+np.float64,0x3fce42ffc73c8600,0xc000a5062678406e,2
+np.float64,0x3f2e6d3c7e5ce,0xc090001304cfd1c7,2
+np.float64,0x3fd4b2e5f7a965cc,0xbffa0e6e6bae0a68,2
+np.float64,0x3fe6db1d18edb63a,0xbfdf128158ee92d9,2
+np.float64,0x7fe4e5792f29caf1,0x408ffb14d9dbf133,2
+np.float64,0x3fc11cdf992239bf,0xc00739569619cd77,2
+np.float64,0x3fc05ea11220bd42,0xc007bc841b48a890,2
+np.float64,0x4bd592d497ab3,0xc08ffe0ab1c962e2,2
+np.float64,0x280068fc5000e,0xc09002b64955e865,2
+np.float64,0x7fe2f2637065e4c6,0x408ff9f379c1253a,2
+np.float64,0x3fefc38467ff8709,0xbf85e53e64b9a424,2
+np.float64,0x2d78ec5a5af1e,0xc09001f8ea8601e0,2
+np.float64,0x7feeef2b957dde56,0x408fff9bebe995f7,2
+np.float64,0x2639baf44c738,0xc09002f9618d623b,2
+np.float64,0x3fc562964d2ac52d,0xc004a6d76959ef78,2
+np.float64,0x3fe21b071fe4360e,0xbfea4adb2cd96ade,2
+np.float64,0x7fe56aa6802ad54c,0x408ffb5d81d1a898,2
+np.float64,0x4296b452852d7,0xc08fff8ad7fbcbe1,2
+np.float64,0x7fe3fac4ff27f589,0x408ffa9049eec479,2
+np.float64,0x7fe7a83e6caf507c,0x408ffc837f436604,2
+np.float64,0x3fc4ac5b872958b7,0xc0050add72381ac3,2
+np.float64,0x3fd6d697c02dad30,0xbff7c931a3eefb01,2
+np.float64,0x3f61e391c023c724,0xc021ad91e754f94b,2
+np.float64,0x10817f9c21031,0xc09007d20434d7bc,2
+np.float64,0x3fdb9c4c4cb73899,0xbff367d8615c5ece,2
+np.float64,0x3fe26ead6b64dd5b,0xbfe977771def5989,2
+np.float64,0x3fc43ea5c3287d4c,0xc00548c2163ae631,2
+np.float64,0x3fe05bd8bba0b7b1,0xbfeef9ea0db91abc,2
+np.float64,0x3feac78369358f07,0xbfd071e2b0aeab39,2
+np.float64,0x7fe254922ca4a923,0x408ff991bdd4e5d3,2
+np.float64,0x3fe5a2f5842b45eb,0xbfe21135c9a71666,2
+np.float64,0x3fd5daf98c2bb5f3,0xbff8cd24f7c07003,2
+np.float64,0x3fcb2a1384365427,0xc001e40f0d04299a,2
+np.float64,0x3fe073974360e72f,0xbfeeb7183a9930b7,2
+np.float64,0xcf3440819e688,0xc08ff270d3a71001,2
+np.float64,0x3fd35656cda6acae,0xbffba083fba4939d,2
+np.float64,0x7fe6c59b4ded8b36,0x408ffc12ce725425,2
+np.float64,0x3fba896f943512df,0xc00a291cb6947701,2
+np.float64,0x7fe54917e86a922f,0x408ffb4b5e0fb848,2
+np.float64,0x7fed2a3f51ba547e,0x408ffeede945a948,2
+np.float64,0x3fdc72bd5038e57b,0xbff2b73b7e93e209,2
+np.float64,0x7fefdb3f9f3fb67e,0x408ffff2b702a768,2
+np.float64,0x3fb0184430203088,0xc00fee8c1351763c,2
+np.float64,0x7d6c3668fad87,0xc08ff83c195f2cca,2
+np.float64,0x3fd5aa254aab544b,0xbff900f16365991b,2
+np.float64,0x3f963daab02c7b55,0xc0161974495b1b71,2
+np.float64,0x3fa7a9c5982f538b,0xc011bde0f6052a89,2
+np.float64,0xb3a5a74b674b5,0xc08ff4167bc97c81,2
+np.float64,0x7fad0c14503a1828,0x408fdee1f2d56cd7,2
+np.float64,0x43e0e9d887c1e,0xc08fff522837b13b,2
+np.float64,0x3fe513b20aea2764,0xbfe346ea994100e6,2
+np.float64,0x7fe4e10393e9c206,0x408ffb12630f6a06,2
+np.float64,0x68b286e2d1651,0xc08ffa51c0d795d4,2
+np.float64,0x7fe8de453331bc89,0x408ffd17012b75ac,2
+np.float64,0x1b3d77d4367b0,0xc09004edea60aa36,2
+np.float64,0x3fd351cbc326a398,0xbffba5f0f4d5fdba,2
+np.float64,0x3fd264951b24c92a,0xbffcc8636788b9bf,2
+np.float64,0xd2465761a48cb,0xc08ff2455c9c53e5,2
+np.float64,0x7fe46a0ef028d41d,0x408ffacfe32c6f5d,2
+np.float64,0x3fafd8ac4c3fb159,0xc010071bf33195d0,2
+np.float64,0x902aec5d2055e,0xc08ff6a08e28aabc,2
+np.float64,0x3fcea61bb03d4c37,0xc0007f76e509b657,2
+np.float64,0x7fe8d90f9571b21e,0x408ffd1495f952e7,2
+np.float64,0x7fa650c9442ca192,0x408fdbd6ff22fdd8,2
+np.float64,0x3fe8ecfdf171d9fc,0xbfd7115df40e8580,2
+np.float64,0x7fd4e6fe7f29cdfc,0x408ff315b0dae183,2
+np.float64,0x77df4c52efbea,0xc08ff8c1d5c1df33,2
+np.float64,0xe200b0cfc4016,0xc08ff1703cfb8e79,2
+np.float64,0x3fe230ea7e2461d5,0xbfea132d2385160e,2
+np.float64,0x7fd1f7ced723ef9d,0x408ff156bfbf92a4,2
+np.float64,0x3fea762818f4ec50,0xbfd18c12a88e5f79,2
+np.float64,0x7feea4ba7c7d4974,0x408fff8004164054,2
+np.float64,0x833ec605067d9,0xc08ff7b606383841,2
+np.float64,0x7fd0c2d7fea185af,0x408ff0894f3a0cf4,2
+np.float64,0x3fe1d7d61d23afac,0xbfeaf76fee875d3e,2
+np.float64,0x65adecb0cb5be,0xc08ffaa82cb09d68,2

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-sinh.csv

@@ -0,0 +1,1429 @@
+dtype,input,output,ulperrortol
+np.float32,0xfee27582,0xff800000,2
+np.float32,0xff19f092,0xff800000,2
+np.float32,0xbf393576,0xbf49cb31,2
+np.float32,0x8020fdea,0x8020fdea,2
+np.float32,0x455f4e,0x455f4e,2
+np.float32,0xff718c35,0xff800000,2
+np.float32,0x3f3215e3,0x3f40cce5,2
+np.float32,0x19e833,0x19e833,2
+np.float32,0xff2dcd49,0xff800000,2
+np.float32,0x7e8f6c95,0x7f800000,2
+np.float32,0xbf159dac,0xbf1e47a5,2
+np.float32,0x100d3d,0x100d3d,2
+np.float32,0xff673441,0xff800000,2
+np.float32,0x80275355,0x80275355,2
+np.float32,0x4812d0,0x4812d0,2
+np.float32,0x8072b956,0x8072b956,2
+np.float32,0xff3bb918,0xff800000,2
+np.float32,0x0,0x0,2
+np.float32,0xfe327798,0xff800000,2
+np.float32,0x41d4e2,0x41d4e2,2
+np.float32,0xfe34b1b8,0xff800000,2
+np.float32,0x80199f72,0x80199f72,2
+np.float32,0x807242ce,0x807242ce,2
+np.float32,0x3ef4202d,0x3efd7b48,2
+np.float32,0x763529,0x763529,2
+np.float32,0x4f6662,0x4f6662,2
+np.float32,0x3f18efe9,0x3f2232b5,2
+np.float32,0x80701846,0x80701846,2
+np.float32,0x3f599948,0x3f74c393,2
+np.float32,0x5a3d69,0x5a3d69,2
+np.float32,0xbf4a7e65,0xbf6047a3,2
+np.float32,0xff0d4c82,0xff800000,2
+np.float32,0x7a74db,0x7a74db,2
+np.float32,0x803388e6,0x803388e6,2
+np.float32,0x7f4430bb,0x7f800000,2
+np.float32,0x14c5b1,0x14c5b1,2
+np.float32,0xfa113400,0xff800000,2
+np.float32,0x7f4b3209,0x7f800000,2
+np.float32,0x8038d88c,0x8038d88c,2
+np.float32,0xbef2f9de,0xbefc330b,2
+np.float32,0xbe147b38,0xbe15008f,2
+np.float32,0x2b61e6,0x2b61e6,2
+np.float32,0x80000001,0x80000001,2
+np.float32,0x8060456c,0x8060456c,2
+np.float32,0x3f30fa82,0x3f3f6a99,2
+np.float32,0xfd1f0220,0xff800000,2
+np.float32,0xbf2b7555,0xbf389151,2
+np.float32,0xff100b7a,0xff800000,2
+np.float32,0x70d3cd,0x70d3cd,2
+np.float32,0x2a8d4a,0x2a8d4a,2
+np.float32,0xbf7b733f,0xbf92f05f,2
+np.float32,0x3f7106dc,0x3f8b1fc6,2
+np.float32,0x3f39da7a,0x3f4a9d79,2
+np.float32,0x3f5dd73f,0x3f7aaab5,2
+np.float32,0xbe8c8754,0xbe8e4cba,2
+np.float32,0xbf6c74c9,0xbf87c556,2
+np.float32,0x800efbbb,0x800efbbb,2
+np.float32,0xff054ab5,0xff800000,2
+np.float32,0x800b4b46,0x800b4b46,2
+np.float32,0xff77fd74,0xff800000,2
+np.float32,0x257d0,0x257d0,2
+np.float32,0x7caa0c,0x7caa0c,2
+np.float32,0x8025d24d,0x8025d24d,2
+np.float32,0x3d9f1b60,0x3d9f445c,2
+np.float32,0xbe3bf6e8,0xbe3d0595,2
+np.float32,0x54bb93,0x54bb93,2
+np.float32,0xbf3e6a45,0xbf507716,2
+np.float32,0x3f4bb26e,0x3f61e1cd,2
+np.float32,0x3f698edc,0x3f85aac5,2
+np.float32,0xff7bd0ef,0xff800000,2
+np.float32,0xbed07b68,0xbed64a8e,2
+np.float32,0xbf237c72,0xbf2ed3d2,2
+np.float32,0x27b0fa,0x27b0fa,2
+np.float32,0x3f7606d1,0x3f8ed7d6,2
+np.float32,0x790dc0,0x790dc0,2
+np.float32,0x7f68f3ac,0x7f800000,2
+np.float32,0xbed39288,0xbed9a52f,2
+np.float32,0x3f6f8266,0x3f8a0187,2
+np.float32,0x3fbdca,0x3fbdca,2
+np.float32,0xbf7c3e5d,0xbf938b2c,2
+np.float32,0x802321a8,0x802321a8,2
+np.float32,0x3eecab66,0x3ef53031,2
+np.float32,0x62b324,0x62b324,2
+np.float32,0x3f13afac,0x3f1c03fe,2
+np.float32,0xff315ad7,0xff800000,2
+np.float32,0xbf1fac0d,0xbf2a3a63,2
+np.float32,0xbf543984,0xbf6d61d6,2
+np.float32,0x71a212,0x71a212,2
+np.float32,0x114fbe,0x114fbe,2
+np.float32,0x3f5b6ff2,0x3f77505f,2
+np.float32,0xff6ff89e,0xff800000,2
+np.float32,0xff4527a1,0xff800000,2
+np.float32,0x22cb3,0x22cb3,2
+np.float32,0x7f53bb6b,0x7f800000,2
+np.float32,0xff3d2dea,0xff800000,2
+np.float32,0xfd21dac0,0xff800000,2
+np.float32,0xfc486140,0xff800000,2
+np.float32,0x7e2b693a,0x7f800000,2
+np.float32,0x8022a9fb,0x8022a9fb,2
+np.float32,0x80765de0,0x80765de0,2
+np.float32,0x13d299,0x13d299,2
+np.float32,0x7ee53713,0x7f800000,2
+np.float32,0xbde1c770,0xbde23c96,2
+np.float32,0xbd473fc0,0xbd4753de,2
+np.float32,0x3f1cb455,0x3f26acf3,2
+np.float32,0x683e49,0x683e49,2
+np.float32,0x3ed5a9fc,0x3edbeb79,2
+np.float32,0x3f4fe3f6,0x3f67814f,2
+np.float32,0x802a2bce,0x802a2bce,2
+np.float32,0x7e951b4c,0x7f800000,2
+np.float32,0xbe6eb260,0xbe70dd44,2
+np.float32,0xbe3daca8,0xbe3ec2cb,2
+np.float32,0xbe9c38b2,0xbe9ea822,2
+np.float32,0xff2e29dc,0xff800000,2
+np.float32,0x7f62c7cc,0x7f800000,2
+np.float32,0xbf6799a4,0xbf84416c,2
+np.float32,0xbe30a7f0,0xbe318898,2
+np.float32,0xc83d9,0xc83d9,2
+np.float32,0x3f05abf4,0x3f0bd447,2
+np.float32,0x7e9b018a,0x7f800000,2
+np.float32,0xbf0ed72e,0xbf165e5b,2
+np.float32,0x8011ac8c,0x8011ac8c,2
+np.float32,0xbeb7c706,0xbebbbfcb,2
+np.float32,0x803637f9,0x803637f9,2
+np.float32,0xfe787cc8,0xff800000,2
+np.float32,0x3f533d4b,0x3f6c0a50,2
+np.float32,0x3f5c0f1c,0x3f782dde,2
+np.float32,0x3f301f36,0x3f3e590d,2
+np.float32,0x2dc929,0x2dc929,2
+np.float32,0xff15018a,0xff800000,2
+np.float32,0x3f4d0c56,0x3f63afeb,2
+np.float32,0xbf7a2ae3,0xbf91f6e4,2
+np.float32,0xbe771b84,0xbe798346,2
+np.float32,0x80800000,0x80800000,2
+np.float32,0x7f5689ba,0x7f800000,2
+np.float32,0x3f1c3177,0x3f2610df,2
+np.float32,0x3f1b9664,0x3f255825,2
+np.float32,0x3f7e5066,0x3f9520d4,2
+np.float32,0xbf1935f8,0xbf2285ab,2
+np.float32,0x3f096cc7,0x3f101ef9,2
+np.float32,0x8030c180,0x8030c180,2
+np.float32,0x6627ed,0x6627ed,2
+np.float32,0x454595,0x454595,2
+np.float32,0x7de66a33,0x7f800000,2
+np.float32,0xbf800000,0xbf966cfe,2
+np.float32,0xbf35c0a8,0xbf456939,2
+np.float32,0x3f6a6266,0x3f8643e0,2
+np.float32,0x3f0cbcee,0x3f13ef6a,2
+np.float32,0x7efd1e58,0x7f800000,2
+np.float32,0xfe9a74c6,0xff800000,2
+np.float32,0x807ebe6c,0x807ebe6c,2
+np.float32,0x80656736,0x80656736,2
+np.float32,0x800e0608,0x800e0608,2
+np.float32,0xbf30e39a,0xbf3f4e00,2
+np.float32,0x802015fd,0x802015fd,2
+np.float32,0x3e3ce26d,0x3e3df519,2
+np.float32,0x7ec142ac,0x7f800000,2
+np.float32,0xbf68c9ce,0xbf851c78,2
+np.float32,0xfede8356,0xff800000,2
+np.float32,0xbf1507ce,0xbf1d978d,2
+np.float32,0x3e53914c,0x3e551374,2
+np.float32,0x7f3e1c14,0x7f800000,2
+np.float32,0x8070d2ba,0x8070d2ba,2
+np.float32,0xbf4eb793,0xbf65ecee,2
+np.float32,0x7365a6,0x7365a6,2
+np.float32,0x8045cba2,0x8045cba2,2
+np.float32,0x7e4af521,0x7f800000,2
+np.float32,0xbf228625,0xbf2da9e1,2
+np.float32,0x7ee0536c,0x7f800000,2
+np.float32,0x3e126607,0x3e12e5d5,2
+np.float32,0x80311d92,0x80311d92,2
+np.float32,0xbf386b8b,0xbf48ca54,2
+np.float32,0x7f800000,0x7f800000,2
+np.float32,0x8049ec7a,0x8049ec7a,2
+np.float32,0xbf1dfde4,0xbf2836be,2
+np.float32,0x7e719a8c,0x7f800000,2
+np.float32,0x3eb9c856,0x3ebde2e6,2
+np.float32,0xfe3efda8,0xff800000,2
+np.float32,0xbe89d60c,0xbe8b81d1,2
+np.float32,0x3eaad338,0x3eae0317,2
+np.float32,0x7f4e5217,0x7f800000,2
+np.float32,0x3e9d0f40,0x3e9f88ce,2
+np.float32,0xbe026708,0xbe02c155,2
+np.float32,0x5fc22f,0x5fc22f,2
+np.float32,0x1c4572,0x1c4572,2
+np.float32,0xbed89d96,0xbedf22c5,2
+np.float32,0xbf3debee,0xbf4fd441,2
+np.float32,0xbf465520,0xbf5ac6e5,2
+np.float32,0x3f797081,0x3f9169b3,2
+np.float32,0xbf250734,0xbf30b2aa,2
+np.float32,0x7f5068e9,0x7f800000,2
+np.float32,0x3f1b814e,0x3f253f0c,2
+np.float32,0xbf27c5d3,0xbf340b05,2
+np.float32,0x3f1b78ae,0x3f2534c8,2
+np.float32,0x8059b51a,0x8059b51a,2
+np.float32,0x8059f182,0x8059f182,2
+np.float32,0xbf1bb36e,0xbf257ab8,2
+np.float32,0x41ac35,0x41ac35,2
+np.float32,0x68f41f,0x68f41f,2
+np.float32,0xbea504dc,0xbea7e40f,2
+np.float32,0x1,0x1,2
+np.float32,0x3e96b5b0,0x3e98e542,2
+np.float32,0x7f7fffff,0x7f800000,2
+np.float32,0x3c557a80,0x3c557c0c,2
+np.float32,0x800ca3ec,0x800ca3ec,2
+np.float32,0x8077d4aa,0x8077d4aa,2
+np.float32,0x3f000af0,0x3f0572d6,2
+np.float32,0x3e0434dd,0x3e0492f8,2
+np.float32,0x7d1a710a,0x7f800000,2
+np.float32,0x3f70f996,0x3f8b15f8,2
+np.float32,0x8033391d,0x8033391d,2
+np.float32,0x11927c,0x11927c,2
+np.float32,0x7f7784be,0x7f800000,2
+np.float32,0x7acb22af,0x7f800000,2
+np.float32,0x7e8b153c,0x7f800000,2
+np.float32,0x66d402,0x66d402,2
+np.float32,0xfed6e7b0,0xff800000,2
+np.float32,0x7f6872d3,0x7f800000,2
+np.float32,0x1bd49c,0x1bd49c,2
+np.float32,0xfdc4f1b8,0xff800000,2
+np.float32,0xbed8a466,0xbedf2a33,2
+np.float32,0x7ee789,0x7ee789,2
+np.float32,0xbece94b4,0xbed43b52,2
+np.float32,0x3cf3f734,0x3cf4006f,2
+np.float32,0x7e44aa00,0x7f800000,2
+np.float32,0x7f19e99c,0x7f800000,2
+np.float32,0x806ff1bc,0x806ff1bc,2
+np.float32,0x80296934,0x80296934,2
+np.float32,0x7f463363,0x7f800000,2
+np.float32,0xbf212ac3,0xbf2c06bb,2
+np.float32,0x3dc63778,0x3dc686ba,2
+np.float32,0x7f1b4328,0x7f800000,2
+np.float32,0x6311f6,0x6311f6,2
+np.float32,0xbf6b6fb6,0xbf870751,2
+np.float32,0xbf2c44cf,0xbf399155,2
+np.float32,0x3e7a67bc,0x3e7ce887,2
+np.float32,0x7f57c5f7,0x7f800000,2
+np.float32,0x7f2bb4ff,0x7f800000,2
+np.float32,0xbe9d448e,0xbe9fc0a4,2
+np.float32,0xbf4840f0,0xbf5d4f6b,2
+np.float32,0x7f1e1176,0x7f800000,2
+np.float32,0xff76638e,0xff800000,2
+np.float32,0xff055555,0xff800000,2
+np.float32,0x3f32b82b,0x3f419834,2
+np.float32,0xff363aa8,0xff800000,2
+np.float32,0x7f737fd0,0x7f800000,2
+np.float32,0x3da5d798,0x3da60602,2
+np.float32,0x3f1cc126,0x3f26bc3e,2
+np.float32,0x7eb07541,0x7f800000,2
+np.float32,0x3f7b2ff2,0x3f92bd2a,2
+np.float32,0x474f7,0x474f7,2
+np.float32,0x7fc00000,0x7fc00000,2
+np.float32,0xff2b0a4e,0xff800000,2
+np.float32,0xfeb24f16,0xff800000,2
+np.float32,0x2cb9fc,0x2cb9fc,2
+np.float32,0x67189d,0x67189d,2
+np.float32,0x8033d854,0x8033d854,2
+np.float32,0xbe85e94c,0xbe87717a,2
+np.float32,0x80767c6c,0x80767c6c,2
+np.float32,0x7ea84d65,0x7f800000,2
+np.float32,0x3f024bc7,0x3f07fead,2
+np.float32,0xbdcb0100,0xbdcb5625,2
+np.float32,0x3f160a9e,0x3f1ec7c9,2
+np.float32,0xff1734c8,0xff800000,2
+np.float32,0x7f424d5e,0x7f800000,2
+np.float32,0xbf75b215,0xbf8e9862,2
+np.float32,0x3f262a42,0x3f3214c4,2
+np.float32,0xbf4cfb53,0xbf639927,2
+np.float32,0x3f4ac8b8,0x3f60aa7c,2
+np.float32,0x3e90e593,0x3e92d6b3,2
+np.float32,0xbf66bccf,0xbf83a2d8,2
+np.float32,0x7d3d851a,0x7f800000,2
+np.float32,0x7bac783c,0x7f800000,2
+np.float32,0x8001c626,0x8001c626,2
+np.float32,0xbdffd480,0xbe003f7b,2
+np.float32,0x7f6680bf,0x7f800000,2
+np.float32,0xbecf448e,0xbed4f9bb,2
+np.float32,0x584c7,0x584c7,2
+np.float32,0x3f3e8ea0,0x3f50a5fb,2
+np.float32,0xbf5a5f04,0xbf75d56e,2
+np.float32,0x8065ae47,0x8065ae47,2
+np.float32,0xbf48dce3,0xbf5e1dba,2
+np.float32,0xbe8dae2e,0xbe8f7ed8,2
+np.float32,0x3f7ca6ab,0x3f93dace,2
+np.float32,0x4c3e81,0x4c3e81,2
+np.float32,0x80000000,0x80000000,2
+np.float32,0x3ee1f7d9,0x3ee96033,2
+np.float32,0x80588c6f,0x80588c6f,2
+np.float32,0x5ba34e,0x5ba34e,2
+np.float32,0x80095d28,0x80095d28,2
+np.float32,0xbe7ba198,0xbe7e2bdd,2
+np.float32,0xbe0bdcb4,0xbe0c4c22,2
+np.float32,0x1776f7,0x1776f7,2
+np.float32,0x80328b2a,0x80328b2a,2
+np.float32,0x3e978d37,0x3e99c63e,2
+np.float32,0x7ed50906,0x7f800000,2
+np.float32,0x3f776a54,0x3f8fe2bd,2
+np.float32,0xbed624c4,0xbedc7120,2
+np.float32,0x7f0b6a31,0x7f800000,2
+np.float32,0x7eb13913,0x7f800000,2
+np.float32,0xbe733684,0xbe758190,2
+np.float32,0x80016474,0x80016474,2
+np.float32,0x7a51ee,0x7a51ee,2
+np.float32,0x3f6cb91e,0x3f87f729,2
+np.float32,0xbd99b050,0xbd99d540,2
+np.float32,0x7c6e3cba,0x7f800000,2
+np.float32,0xbf00179a,0xbf05811e,2
+np.float32,0x3e609b29,0x3e626954,2
+np.float32,0xff3fd71a,0xff800000,2
+np.float32,0x5d8c2,0x5d8c2,2
+np.float32,0x7ee93662,0x7f800000,2
+np.float32,0x4b0b31,0x4b0b31,2
+np.float32,0x3ec243b7,0x3ec6f594,2
+np.float32,0x804d60f1,0x804d60f1,2
+np.float32,0xbf0cb784,0xbf13e929,2
+np.float32,0x3f13b74d,0x3f1c0cee,2
+np.float32,0xfe37cb64,0xff800000,2
+np.float32,0x1a88,0x1a88,2
+np.float32,0x3e22a472,0x3e2353ba,2
+np.float32,0x7f07d6a0,0x7f800000,2
+np.float32,0x3f78f435,0x3f910bb5,2
+np.float32,0x555a4a,0x555a4a,2
+np.float32,0x3e306c1f,0x3e314be3,2
+np.float32,0x8005877c,0x8005877c,2
+np.float32,0x4df389,0x4df389,2
+np.float32,0x8069ffc7,0x8069ffc7,2
+np.float32,0x3f328f24,0x3f4164c6,2
+np.float32,0x53a31b,0x53a31b,2
+np.float32,0xbe4d6768,0xbe4ec8be,2
+np.float32,0x7fa00000,0x7fe00000,2
+np.float32,0x3f484c1b,0x3f5d5e2f,2
+np.float32,0x8038be05,0x8038be05,2
+np.float32,0x58ac0f,0x58ac0f,2
+np.float32,0x7ed7fb72,0x7f800000,2
+np.float32,0x5a22e1,0x5a22e1,2
+np.float32,0xbebb7394,0xbebfaad6,2
+np.float32,0xbda98160,0xbda9b2ef,2
+np.float32,0x7f3e5c42,0x7f800000,2
+np.float32,0xfed204ae,0xff800000,2
+np.float32,0xbf5ef782,0xbf7c3ec5,2
+np.float32,0xbef7a0a8,0xbf00b292,2
+np.float32,0xfee6e176,0xff800000,2
+np.float32,0xfe121140,0xff800000,2
+np.float32,0xfe9e13be,0xff800000,2
+np.float32,0xbf3c98b1,0xbf4e2003,2
+np.float32,0x77520d,0x77520d,2
+np.float32,0xf17b2,0xf17b2,2
+np.float32,0x724d2f,0x724d2f,2
+np.float32,0x7eb326f5,0x7f800000,2
+np.float32,0x3edd6bf2,0x3ee4636e,2
+np.float32,0x350f57,0x350f57,2
+np.float32,0xff7d4435,0xff800000,2
+np.float32,0x802b2b9d,0x802b2b9d,2
+np.float32,0xbf7fbeee,0xbf963acf,2
+np.float32,0x804f3100,0x804f3100,2
+np.float32,0x7c594a71,0x7f800000,2
+np.float32,0x3ef49340,0x3efdfbb6,2
+np.float32,0x2e0659,0x2e0659,2
+np.float32,0x8006d5fe,0x8006d5fe,2
+np.float32,0xfd2a00b0,0xff800000,2
+np.float32,0xbee1c016,0xbee922ed,2
+np.float32,0x3e3b7de8,0x3e3c8a8b,2
+np.float32,0x805e6bba,0x805e6bba,2
+np.float32,0x1a7da2,0x1a7da2,2
+np.float32,0x6caba4,0x6caba4,2
+np.float32,0x802f7eab,0x802f7eab,2
+np.float32,0xff68b16b,0xff800000,2
+np.float32,0x8064f5e5,0x8064f5e5,2
+np.float32,0x2e39b4,0x2e39b4,2
+np.float32,0x800000,0x800000,2
+np.float32,0xfd0334c0,0xff800000,2
+np.float32,0x3e952fc4,0x3e974e7e,2
+np.float32,0x80057d33,0x80057d33,2
+np.float32,0x3ed3ddc4,0x3ed9f6f1,2
+np.float32,0x3f74ce18,0x3f8dedf4,2
+np.float32,0xff6bb7c0,0xff800000,2
+np.float32,0xff43bc21,0xff800000,2
+np.float32,0x80207570,0x80207570,2
+np.float32,0x7e1dda75,0x7f800000,2
+np.float32,0x3efe335c,0x3f0462ff,2
+np.float32,0xbf252c0c,0xbf30df70,2
+np.float32,0x3ef4b8e3,0x3efe25ba,2
+np.float32,0x7c33938d,0x7f800000,2
+np.float32,0x3eb1593c,0x3eb4ea95,2
+np.float32,0xfe1d0068,0xff800000,2
+np.float32,0xbf10da9b,0xbf18b551,2
+np.float32,0xfeb65748,0xff800000,2
+np.float32,0xfe8c6014,0xff800000,2
+np.float32,0x3f0503e2,0x3f0b14e3,2
+np.float32,0xfe5e5248,0xff800000,2
+np.float32,0xbd10afa0,0xbd10b754,2
+np.float32,0xff64b609,0xff800000,2
+np.float32,0xbf674a96,0xbf84089c,2
+np.float32,0x7f5d200d,0x7f800000,2
+np.float32,0x3cf44900,0x3cf45245,2
+np.float32,0x8044445a,0x8044445a,2
+np.float32,0xff35b676,0xff800000,2
+np.float32,0x806452cd,0x806452cd,2
+np.float32,0xbf2930fb,0xbf35c7b4,2
+np.float32,0x7e500617,0x7f800000,2
+np.float32,0x543719,0x543719,2
+np.float32,0x3ed11068,0x3ed6ec1d,2
+np.float32,0xbd8db068,0xbd8dcd59,2
+np.float32,0x3ede62c8,0x3ee571d0,2
+np.float32,0xbf00a410,0xbf061f9c,2
+np.float32,0xbf44fa39,0xbf58ff5b,2
+np.float32,0x3f1c3114,0x3f261069,2
+np.float32,0xbdea6210,0xbdeae521,2
+np.float32,0x80059f6d,0x80059f6d,2
+np.float32,0xbdba15f8,0xbdba578c,2
+np.float32,0x6d8a61,0x6d8a61,2
+np.float32,0x6f5428,0x6f5428,2
+np.float32,0x18d0e,0x18d0e,2
+np.float32,0x50e131,0x50e131,2
+np.float32,0x3f2f52be,0x3f3d5a7e,2
+np.float32,0x7399d8,0x7399d8,2
+np.float32,0x106524,0x106524,2
+np.float32,0x7ebf1c53,0x7f800000,2
+np.float32,0x80276458,0x80276458,2
+np.float32,0x3ebbde67,0x3ec01ceb,2
+np.float32,0x80144d9d,0x80144d9d,2
+np.float32,0x8017ea6b,0x8017ea6b,2
+np.float32,0xff38f201,0xff800000,2
+np.float32,0x7f2daa82,0x7f800000,2
+np.float32,0x3f3cb7c7,0x3f4e47ed,2
+np.float32,0x7f08c779,0x7f800000,2
+np.float32,0xbecc907a,0xbed20cec,2
+np.float32,0x7d440002,0x7f800000,2
+np.float32,0xbd410d80,0xbd411fcd,2
+np.float32,0x3d63ae07,0x3d63cc0c,2
+np.float32,0x805a9c13,0x805a9c13,2
+np.float32,0x803bdcdc,0x803bdcdc,2
+np.float32,0xbe88b354,0xbe8a5497,2
+np.float32,0x3f4eaf43,0x3f65e1c2,2
+np.float32,0x3f15e5b8,0x3f1e9c60,2
+np.float32,0x3e8a870c,0x3e8c394e,2
+np.float32,0x7e113de9,0x7f800000,2
+np.float32,0x7ee5ba41,0x7f800000,2
+np.float32,0xbe73d178,0xbe7620eb,2
+np.float32,0xfe972e6a,0xff800000,2
+np.float32,0xbf65567d,0xbf82a25a,2
+np.float32,0x3f38247e,0x3f487010,2
+np.float32,0xbece1c62,0xbed3b918,2
+np.float32,0x442c8d,0x442c8d,2
+np.float32,0x2dc52,0x2dc52,2
+np.float32,0x802ed923,0x802ed923,2
+np.float32,0x788cf8,0x788cf8,2
+np.float32,0x8024888e,0x8024888e,2
+np.float32,0x3f789bde,0x3f90c8fc,2
+np.float32,0x3f5de620,0x3f7abf88,2
+np.float32,0x3f0ffc45,0x3f17b2a7,2
+np.float32,0xbf709678,0xbf8accd4,2
+np.float32,0x12181f,0x12181f,2
+np.float32,0xfe54bbe4,0xff800000,2
+np.float32,0x7f1daba0,0x7f800000,2
+np.float32,0xbf6226df,0xbf805e3c,2
+np.float32,0xbd120610,0xbd120dfb,2
+np.float32,0x7f75e951,0x7f800000,2
+np.float32,0x80068048,0x80068048,2
+np.float32,0x45f04a,0x45f04a,2
+np.float32,0xff4c4f58,0xff800000,2
+np.float32,0x311604,0x311604,2
+np.float32,0x805e809c,0x805e809c,2
+np.float32,0x3d1d62c0,0x3d1d6caa,2
+np.float32,0x7f14ccf9,0x7f800000,2
+np.float32,0xff10017c,0xff800000,2
+np.float32,0xbf43ec48,0xbf579df4,2
+np.float32,0xff64da57,0xff800000,2
+np.float32,0x7f0622c5,0x7f800000,2
+np.float32,0x7f5460cd,0x7f800000,2
+np.float32,0xff0ef1c6,0xff800000,2
+np.float32,0xbece1146,0xbed3ad13,2
+np.float32,0x3f4d457f,0x3f63fc70,2
+np.float32,0xbdc1da28,0xbdc2244b,2
+np.float32,0xbe46d3f4,0xbe481463,2
+np.float32,0xff36b3d6,0xff800000,2
+np.float32,0xbec2e76c,0xbec7a540,2
+np.float32,0x8078fb81,0x8078fb81,2
+np.float32,0x7ec819cb,0x7f800000,2
+np.float32,0x39c4d,0x39c4d,2
+np.float32,0xbe8cddc2,0xbe8ea670,2
+np.float32,0xbf36dffb,0xbf46d48b,2
+np.float32,0xbf2302a3,0xbf2e4065,2
+np.float32,0x3e7b34a2,0x3e7dbb9a,2
+np.float32,0x3e3d87e1,0x3e3e9d62,2
+np.float32,0x7f3c94b1,0x7f800000,2
+np.float32,0x80455a85,0x80455a85,2
+np.float32,0xfd875568,0xff800000,2
+np.float32,0xbf618103,0xbf7fd1c8,2
+np.float32,0xbe332e3c,0xbe3418ac,2
+np.float32,0x80736b79,0x80736b79,2
+np.float32,0x3f705d9a,0x3f8aa2e6,2
+np.float32,0xbf3a36d2,0xbf4b134b,2
+np.float32,0xfddc55c0,0xff800000,2
+np.float32,0x805606fd,0x805606fd,2
+np.float32,0x3f4f0bc4,0x3f665e25,2
+np.float32,0xfebe7494,0xff800000,2
+np.float32,0xff0c541b,0xff800000,2
+np.float32,0xff0b8e7f,0xff800000,2
+np.float32,0xbcc51640,0xbcc51b1e,2
+np.float32,0x7ec1c4d0,0x7f800000,2
+np.float32,0xfc5c8e00,0xff800000,2
+np.float32,0x7f48d682,0x7f800000,2
+np.float32,0x7d5c7d8d,0x7f800000,2
+np.float32,0x8052ed03,0x8052ed03,2
+np.float32,0x7d4db058,0x7f800000,2
+np.float32,0xff3a65ee,0xff800000,2
+np.float32,0x806eeb93,0x806eeb93,2
+np.float32,0x803f9733,0x803f9733,2
+np.float32,0xbf2d1388,0xbf3a90e3,2
+np.float32,0x68e260,0x68e260,2
+np.float32,0x3e47a69f,0x3e48eb0e,2
+np.float32,0x3f0c4623,0x3f136646,2
+np.float32,0x3f37a831,0x3f47d249,2
+np.float32,0xff153a0c,0xff800000,2
+np.float32,0x2e8086,0x2e8086,2
+np.float32,0xc3f5e,0xc3f5e,2
+np.float32,0x7f31dc14,0x7f800000,2
+np.float32,0xfee37d68,0xff800000,2
+np.float32,0x711d4,0x711d4,2
+np.float32,0x7ede2ce4,0x7f800000,2
+np.float32,0xbf5d76d0,0xbf7a23d0,2
+np.float32,0xbe2b9eb4,0xbe2c6cac,2
+np.float32,0x2b14d7,0x2b14d7,2
+np.float32,0x3ea1db72,0x3ea4910e,2
+np.float32,0x7f3f03f7,0x7f800000,2
+np.float32,0x92de5,0x92de5,2
+np.float32,0x80322e1b,0x80322e1b,2
+np.float32,0xbf5eb214,0xbf7bdd55,2
+np.float32,0xbf21bf87,0xbf2cba14,2
+np.float32,0xbf5d4b78,0xbf79e73a,2
+np.float32,0xbc302840,0xbc30291e,2
+np.float32,0xfee567c6,0xff800000,2
+np.float32,0x7f70ee14,0x7f800000,2
+np.float32,0x7e5c4b33,0x7f800000,2
+np.float32,0x3f1e7b64,0x3f28ccfd,2
+np.float32,0xbf6309f7,0xbf80ff3e,2
+np.float32,0x1c2fe3,0x1c2fe3,2
+np.float32,0x8e78d,0x8e78d,2
+np.float32,0x7f2fce73,0x7f800000,2
+np.float32,0x7f25f690,0x7f800000,2
+np.float32,0x8074cba5,0x8074cba5,2
+np.float32,0x16975f,0x16975f,2
+np.float32,0x8012cf5c,0x8012cf5c,2
+np.float32,0x7da72138,0x7f800000,2
+np.float32,0xbf563f35,0xbf7025be,2
+np.float32,0x3f69d3f5,0x3f85dcbe,2
+np.float32,0xbf15c148,0xbf1e7184,2
+np.float32,0xbe7a077c,0xbe7c8564,2
+np.float32,0x3ebb6ef1,0x3ebfa5e3,2
+np.float32,0xbe41fde4,0xbe43277b,2
+np.float32,0x7f10b479,0x7f800000,2
+np.float32,0x3e021ace,0x3e02747d,2
+np.float32,0x3e93d984,0x3e95e9be,2
+np.float32,0xfe17e924,0xff800000,2
+np.float32,0xfe21a7cc,0xff800000,2
+np.float32,0x8019b660,0x8019b660,2
+np.float32,0x7e954631,0x7f800000,2
+np.float32,0x7e7330d1,0x7f800000,2
+np.float32,0xbe007d98,0xbe00d3fb,2
+np.float32,0x3ef3870e,0x3efcd077,2
+np.float32,0x7f5bbde8,0x7f800000,2
+np.float32,0x14a5b3,0x14a5b3,2
+np.float32,0x3e84d23f,0x3e8650e8,2
+np.float32,0x80763017,0x80763017,2
+np.float32,0xfe871f36,0xff800000,2
+np.float32,0x7ed43150,0x7f800000,2
+np.float32,0x3cc44547,0x3cc44a16,2
+np.float32,0x3ef0c0fa,0x3ef9b97d,2
+np.float32,0xbede9944,0xbee5ad86,2
+np.float32,0xbf10f0b2,0xbf18cf0a,2
+np.float32,0x3ecdaa78,0x3ed33dd9,2
+np.float32,0x3f7cc058,0x3f93ee6b,2
+np.float32,0x2d952f,0x2d952f,2
+np.float32,0x3f2cf2de,0x3f3a687a,2
+np.float32,0x8029b33c,0x8029b33c,2
+np.float32,0xbf22c737,0xbf2df888,2
+np.float32,0xff53c84a,0xff800000,2
+np.float32,0x40a509,0x40a509,2
+np.float32,0x56abce,0x56abce,2
+np.float32,0xff7fffff,0xff800000,2
+np.float32,0xbf3e67f6,0xbf50741c,2
+np.float32,0xfde67580,0xff800000,2
+np.float32,0x3f103e9b,0x3f17ffc7,2
+np.float32,0x3f3f7232,0x3f51cbe2,2
+np.float32,0x803e6d78,0x803e6d78,2
+np.float32,0x3a61da,0x3a61da,2
+np.float32,0xbc04de80,0xbc04dedf,2
+np.float32,0x7f1e7c52,0x7f800000,2
+np.float32,0x8058ee88,0x8058ee88,2
+np.float32,0x806dd660,0x806dd660,2
+np.float32,0x7e4af9,0x7e4af9,2
+np.float32,0x80702d27,0x80702d27,2
+np.float32,0x802cdad1,0x802cdad1,2
+np.float32,0x3e9b5c23,0x3e9dc149,2
+np.float32,0x7f076e89,0x7f800000,2
+np.float32,0x7f129d68,0x7f800000,2
+np.float32,0x7f6f0b0a,0x7f800000,2
+np.float32,0x7eafafb5,0x7f800000,2
+np.float32,0xbf2ef2ca,0xbf3ce332,2
+np.float32,0xff34c000,0xff800000,2
+np.float32,0x7f559274,0x7f800000,2
+np.float32,0xfed08556,0xff800000,2
+np.float32,0xbf014621,0xbf06d6ad,2
+np.float32,0xff23086a,0xff800000,2
+np.float32,0x6cb33f,0x6cb33f,2
+np.float32,0xfe6e3ffc,0xff800000,2
+np.float32,0x3e6bbec0,0x3e6dd546,2
+np.float32,0x8036afa6,0x8036afa6,2
+np.float32,0xff800000,0xff800000,2
+np.float32,0x3e0ed05c,0x3e0f46ff,2
+np.float32,0x3ec9215c,0x3ece57e6,2
+np.float32,0xbf449fa4,0xbf5888aa,2
+np.float32,0xff2c6640,0xff800000,2
+np.float32,0x7f08f4a7,0x7f800000,2
+np.float32,0xbf4f63e5,0xbf66d4c1,2
+np.float32,0x3f800000,0x3f966cfe,2
+np.float32,0xfe86c7d2,0xff800000,2
+np.float32,0x3f63f969,0x3f81a970,2
+np.float32,0xbd7022d0,0xbd704609,2
+np.float32,0xbead906c,0xbeb0e853,2
+np.float32,0x7ef149ee,0x7f800000,2
+np.float32,0xff0b9ff7,0xff800000,2
+np.float32,0x3f38380d,0x3f4888e7,2
+np.float32,0x3ef3a3e2,0x3efcf09e,2
+np.float32,0xff616477,0xff800000,2
+np.float32,0x3f3f83e4,0x3f51e2c3,2
+np.float32,0xbf79963c,0xbf918642,2
+np.float32,0x801416f4,0x801416f4,2
+np.float32,0xff75ce6d,0xff800000,2
+np.float32,0xbdbf3588,0xbdbf7cad,2
+np.float32,0xbe6ea938,0xbe70d3dc,2
+np.float32,0x8066f977,0x8066f977,2
+np.float32,0x3f5b5362,0x3f7728aa,2
+np.float32,0xbf72052c,0xbf8bdbd8,2
+np.float32,0xbe21ed74,0xbe229a6f,2
+np.float32,0x8062d19c,0x8062d19c,2
+np.float32,0x3ed8d01f,0x3edf59e6,2
+np.float32,0x803ed42b,0x803ed42b,2
+np.float32,0xbe099a64,0xbe0a0481,2
+np.float32,0xbe173eb4,0xbe17cba2,2
+np.float32,0xbebdcf02,0xbec22faf,2
+np.float32,0x7e3ff29e,0x7f800000,2
+np.float32,0x367c92,0x367c92,2
+np.float32,0xbf5c9db8,0xbf78f4a4,2
+np.float32,0xff0b49ea,0xff800000,2
+np.float32,0x3f4f9bc4,0x3f672001,2
+np.float32,0x85d4a,0x85d4a,2
+np.float32,0x80643e33,0x80643e33,2
+np.float32,0x8013aabd,0x8013aabd,2
+np.float32,0xff6997c3,0xff800000,2
+np.float32,0x3f4dd43c,0x3f64bbb6,2
+np.float32,0xff13bbb9,0xff800000,2
+np.float32,0x3f34efa2,0x3f446187,2
+np.float32,0x3e4b2f10,0x3e4c850d,2
+np.float32,0xfef695c6,0xff800000,2
+np.float32,0x7f7e0057,0x7f800000,2
+np.float32,0x3f6e1b9c,0x3f88fa40,2
+np.float32,0x806e46cf,0x806e46cf,2
+np.float32,0x3f15a88a,0x3f1e546c,2
+np.float32,0xbd2de7d0,0xbd2df530,2
+np.float32,0xbf63cae0,0xbf818854,2
+np.float32,0xbdc3e1a0,0xbdc42e1e,2
+np.float32,0xbf11a038,0xbf199b98,2
+np.float32,0xbec13706,0xbec5d56b,2
+np.float32,0x3f1c5f54,0x3f26478d,2
+np.float32,0x3e9ea97e,0x3ea136b4,2
+np.float32,0xfeb5a508,0xff800000,2
+np.float32,0x7f4698f4,0x7f800000,2
+np.float32,0xff51ee2c,0xff800000,2
+np.float32,0xff5994df,0xff800000,2
+np.float32,0x4b9fb9,0x4b9fb9,2
+np.float32,0xfda10d98,0xff800000,2
+np.float32,0x525555,0x525555,2
+np.float32,0x7ed571ef,0x7f800000,2
+np.float32,0xbf600d18,0xbf7dc50c,2
+np.float32,0x3ec674ca,0x3ecb768b,2
+np.float32,0x3cb69115,0x3cb694f3,2
+np.float32,0x7eac75f2,0x7f800000,2
+np.float32,0x804d4d75,0x804d4d75,2
+np.float32,0xfed5292e,0xff800000,2
+np.float32,0x800ed06a,0x800ed06a,2
+np.float32,0xfec37584,0xff800000,2
+np.float32,0x3ef96ac7,0x3f01b326,2
+np.float32,0x42f743,0x42f743,2
+np.float32,0x3f56f442,0x3f711e39,2
+np.float32,0xbf7ea726,0xbf956375,2
+np.float32,0x806c7202,0x806c7202,2
+np.float32,0xbd8ee980,0xbd8f0733,2
+np.float32,0xbdf2e930,0xbdf37b18,2
+np.float32,0x3f103910,0x3f17f955,2
+np.float32,0xff123e8f,0xff800000,2
+np.float32,0x806e4b5d,0x806e4b5d,2
+np.float32,0xbf4f3bfc,0xbf669f07,2
+np.float32,0xbf070c16,0xbf0d6609,2
+np.float32,0xff00e0ba,0xff800000,2
+np.float32,0xff49d828,0xff800000,2
+np.float32,0x7e47f04a,0x7f800000,2
+np.float32,0x7e984dac,0x7f800000,2
+np.float32,0x3f77473c,0x3f8fc858,2
+np.float32,0x3f017439,0x3f070ac8,2
+np.float32,0x118417,0x118417,2
+np.float32,0xbcf7a2c0,0xbcf7ac68,2
+np.float32,0xfee46fee,0xff800000,2
+np.float32,0x3e42a648,0x3e43d2e9,2
+np.float32,0x80131916,0x80131916,2
+np.float32,0x806209d3,0x806209d3,2
+np.float32,0x807c1f12,0x807c1f12,2
+np.float32,0x2f3696,0x2f3696,2
+np.float32,0xff28722b,0xff800000,2
+np.float32,0x7f1416a1,0x7f800000,2
+np.float32,0x8054e7a1,0x8054e7a1,2
+np.float32,0xbddc39a0,0xbddca656,2
+np.float32,0x7dc60175,0x7f800000,2
+np.float64,0x7fd0ae584da15cb0,0x7ff0000000000000,2
+np.float64,0x7fd41d68e5283ad1,0x7ff0000000000000,2
+np.float64,0x7fe93073bb7260e6,0x7ff0000000000000,2
+np.float64,0x3fb4fd19d229fa34,0x3fb5031f57dbac0f,2
+np.float64,0x85609ce10ac2,0x85609ce10ac2,2
+np.float64,0xbfd7aa12ccaf5426,0xbfd8351003a320e2,2
+np.float64,0x8004487c9b4890fa,0x8004487c9b4890fa,2
+np.float64,0x7fe7584cfd2eb099,0x7ff0000000000000,2
+np.float64,0x800ea8edc6dd51dc,0x800ea8edc6dd51dc,2
+np.float64,0x3fe0924aa5a12495,0x3fe15276e271c6dc,2
+np.float64,0x3feb1abf6d36357f,0x3fee76b4d3d06964,2
+np.float64,0x3fa8c14534318280,0x3fa8c3bd5ce5923c,2
+np.float64,0x800b9f5915d73eb3,0x800b9f5915d73eb3,2
+np.float64,0xffc05aaa7820b554,0xfff0000000000000,2
+np.float64,0x800157eda8c2afdc,0x800157eda8c2afdc,2
+np.float64,0xffe8d90042b1b200,0xfff0000000000000,2
+np.float64,0x3feda02ea93b405d,0x3ff1057e61d08d59,2
+np.float64,0xffd03b7361a076e6,0xfff0000000000000,2
+np.float64,0x3fe1a8ecd7e351da,0x3fe291eda9080847,2
+np.float64,0xffc5bfdff82b7fc0,0xfff0000000000000,2
+np.float64,0xbfe6fb3d386df67a,0xbfe9022c05df0565,2
+np.float64,0x7fefffffffffffff,0x7ff0000000000000,2
+np.float64,0x7fa10c340c221867,0x7ff0000000000000,2
+np.float64,0x3fe55cbf1daab97e,0x3fe6fc1648258b75,2
+np.float64,0xbfddeb5f60bbd6be,0xbfdf056d4fb5825f,2
+np.float64,0xffddb1a8213b6350,0xfff0000000000000,2
+np.float64,0xbfb20545e4240a88,0xbfb2091579375176,2
+np.float64,0x3f735ded2026bbda,0x3f735df1dad4ee3a,2
+np.float64,0xbfd1eb91efa3d724,0xbfd227c044dead61,2
+np.float64,0xffd737c588ae6f8c,0xfff0000000000000,2
+np.float64,0x3fc46818ec28d032,0x3fc47e416c4237a6,2
+np.float64,0x0,0x0,2
+np.float64,0xffb632097a2c6410,0xfff0000000000000,2
+np.float64,0xbfcb5ae84b36b5d0,0xbfcb905613af55b8,2
+np.float64,0xbfe7b926402f724c,0xbfe9f4f0be6aacc3,2
+np.float64,0x80081840b3f03082,0x80081840b3f03082,2
+np.float64,0x3fe767a656eecf4d,0x3fe98c53b4779de7,2
+np.float64,0x8005834c088b0699,0x8005834c088b0699,2
+np.float64,0x80074e92658e9d26,0x80074e92658e9d26,2
+np.float64,0x80045d60c268bac2,0x80045d60c268bac2,2
+np.float64,0xffb9aecfe8335da0,0xfff0000000000000,2
+np.float64,0x7fcad3e1cd35a7c3,0x7ff0000000000000,2
+np.float64,0xbf881853d03030c0,0xbf8818783e28fc87,2
+np.float64,0xe18c6d23c318e,0xe18c6d23c318e,2
+np.float64,0x7fcb367b8f366cf6,0x7ff0000000000000,2
+np.float64,0x5c13436cb8269,0x5c13436cb8269,2
+np.float64,0xffe5399938aa7332,0xfff0000000000000,2
+np.float64,0xbfdc45dbc3b88bb8,0xbfdd33958222c27e,2
+np.float64,0xbfd714691bae28d2,0xbfd7954edbef810b,2
+np.float64,0xbfdf18b02b3e3160,0xbfe02ad13634c651,2
+np.float64,0x8003e6f276e7cde6,0x8003e6f276e7cde6,2
+np.float64,0x3febb6b412776d68,0x3fef4f753def31f9,2
+np.float64,0x7fe016a3b4a02d46,0x7ff0000000000000,2
+np.float64,0x3fdc899ac7b91336,0x3fdd7e1cee1cdfc8,2
+np.float64,0x800219271e24324f,0x800219271e24324f,2
+np.float64,0x1529d93e2a53c,0x1529d93e2a53c,2
+np.float64,0x800d5bc827fab790,0x800d5bc827fab790,2
+np.float64,0x3e1495107c293,0x3e1495107c293,2
+np.float64,0x3fe89da0f2b13b42,0x3feb1dc1f3015ad7,2
+np.float64,0x800ba8c17b975183,0x800ba8c17b975183,2
+np.float64,0x8002dacf0265b59f,0x8002dacf0265b59f,2
+np.float64,0xffe6d0a4cc2da149,0xfff0000000000000,2
+np.float64,0x3fdf23fe82be47fc,0x3fe03126d8e2b309,2
+np.float64,0xffe41b1f1c28363e,0xfff0000000000000,2
+np.float64,0xbfd635c634ac6b8c,0xbfd6a8966da6adaa,2
+np.float64,0x800755bc08eeab79,0x800755bc08eeab79,2
+np.float64,0x800ba4c47c374989,0x800ba4c47c374989,2
+np.float64,0x7fec9f7649793eec,0x7ff0000000000000,2
+np.float64,0x7fdbf45738b7e8ad,0x7ff0000000000000,2
+np.float64,0x3f5597f07eab4,0x3f5597f07eab4,2
+np.float64,0xbfbf4599183e8b30,0xbfbf5985d8c65097,2
+np.float64,0xbf5b200580364000,0xbf5b2006501b21ae,2
+np.float64,0x7f91868370230d06,0x7ff0000000000000,2
+np.float64,0x3838e2a67071d,0x3838e2a67071d,2
+np.float64,0xffefe3ff5d3fc7fe,0xfff0000000000000,2
+np.float64,0xffe66b26d06cd64d,0xfff0000000000000,2
+np.float64,0xbfd830a571b0614a,0xbfd8c526927c742c,2
+np.float64,0x7fe8442122f08841,0x7ff0000000000000,2
+np.float64,0x800efa8c637df519,0x800efa8c637df519,2
+np.float64,0xf0026835e004d,0xf0026835e004d,2
+np.float64,0xffb11beefe2237e0,0xfff0000000000000,2
+np.float64,0x3fef9bbb327f3776,0x3ff2809f10641c32,2
+np.float64,0x350595306a0b3,0x350595306a0b3,2
+np.float64,0xf7f6538befecb,0xf7f6538befecb,2
+np.float64,0xffe36379c4a6c6f3,0xfff0000000000000,2
+np.float64,0x28b1d82e5163c,0x28b1d82e5163c,2
+np.float64,0x70a3d804e147c,0x70a3d804e147c,2
+np.float64,0xffd96c1bc9b2d838,0xfff0000000000000,2
+np.float64,0xffce8e00893d1c00,0xfff0000000000000,2
+np.float64,0x800f2bdcb25e57b9,0x800f2bdcb25e57b9,2
+np.float64,0xbfe0d9c63361b38c,0xbfe1a3eb02192b76,2
+np.float64,0xbfdc7b8711b8f70e,0xbfdd6e9db3a01e51,2
+np.float64,0x99e22ec133c46,0x99e22ec133c46,2
+np.float64,0xffeaef6ddab5dedb,0xfff0000000000000,2
+np.float64,0x7fe89c22c0f13845,0x7ff0000000000000,2
+np.float64,0x8002d5207de5aa42,0x8002d5207de5aa42,2
+np.float64,0x3fd1b13353236267,0x3fd1eb1b9345dfca,2
+np.float64,0x800ccae0a41995c1,0x800ccae0a41995c1,2
+np.float64,0x3fdbdaba38b7b574,0x3fdcbdfcbca37ce6,2
+np.float64,0x5b06d12cb60db,0x5b06d12cb60db,2
+np.float64,0xffd52262752a44c4,0xfff0000000000000,2
+np.float64,0x5a17f050b42ff,0x5a17f050b42ff,2
+np.float64,0x3d24205e7a485,0x3d24205e7a485,2
+np.float64,0x7fbed4dec63da9bd,0x7ff0000000000000,2
+np.float64,0xbfe56e9776aadd2f,0xbfe71212863c284f,2
+np.float64,0x7fea0bc952341792,0x7ff0000000000000,2
+np.float64,0x800f692d139ed25a,0x800f692d139ed25a,2
+np.float64,0xffdb63feab36c7fe,0xfff0000000000000,2
+np.float64,0x3fe1c2297fe38452,0x3fe2af21293c9571,2
+np.float64,0x7fede384747bc708,0x7ff0000000000000,2
+np.float64,0x800440169288802e,0x800440169288802e,2
+np.float64,0xffe3241eeb26483e,0xfff0000000000000,2
+np.float64,0xffe28f3879651e70,0xfff0000000000000,2
+np.float64,0xa435cbc1486d,0xa435cbc1486d,2
+np.float64,0x7fe55e08db6abc11,0x7ff0000000000000,2
+np.float64,0x1405e624280be,0x1405e624280be,2
+np.float64,0x3fd861bdf0b0c37c,0x3fd8f9d2e33e45e5,2
+np.float64,0x3feeb67cdc3d6cfa,0x3ff1d337d81d1c14,2
+np.float64,0x3fd159a10e22b342,0x3fd1903be7c2ea0c,2
+np.float64,0x3fd84626bc308c4d,0x3fd8dc373645e65b,2
+np.float64,0xffd3da81d9a7b504,0xfff0000000000000,2
+np.float64,0xbfd4a768b8294ed2,0xbfd503aa7c240051,2
+np.float64,0x3fe3059f2a660b3e,0x3fe42983e0c6bb2e,2
+np.float64,0x3fe3b8353827706a,0x3fe4fdd635c7269b,2
+np.float64,0xbfe4af0399695e07,0xbfe6277d9002b46c,2
+np.float64,0xbfd7e18a92afc316,0xbfd87066b54c4fe6,2
+np.float64,0x800432bcab48657a,0x800432bcab48657a,2
+np.float64,0x80033d609d267ac2,0x80033d609d267ac2,2
+np.float64,0x7fef5f758e7ebeea,0x7ff0000000000000,2
+np.float64,0xbfed7833dbfaf068,0xbff0e85bf45a5ebc,2
+np.float64,0x3fe2283985a45073,0x3fe325b0a9099c74,2
+np.float64,0xe820b4b3d0417,0xe820b4b3d0417,2
+np.float64,0x8003ecb72aa7d96f,0x8003ecb72aa7d96f,2
+np.float64,0xbfeab2c755b5658f,0xbfede7c83e92a625,2
+np.float64,0xbfc7b287f72f6510,0xbfc7d53ef2ffe9dc,2
+np.float64,0xffd9a41d0f33483a,0xfff0000000000000,2
+np.float64,0x3fd3a5b6e3a74b6c,0x3fd3f516f39a4725,2
+np.float64,0x800bc72091578e42,0x800bc72091578e42,2
+np.float64,0x800ff405ce9fe80c,0x800ff405ce9fe80c,2
+np.float64,0x57918600af24,0x57918600af24,2
+np.float64,0x2a5be7fa54b7e,0x2a5be7fa54b7e,2
+np.float64,0xbfdca7886bb94f10,0xbfdd9f142b5b43e4,2
+np.float64,0xbfe216993ee42d32,0xbfe3112936590995,2
+np.float64,0xbfe06bd9cf20d7b4,0xbfe126cd353ab42f,2
+np.float64,0x8003e6c31827cd87,0x8003e6c31827cd87,2
+np.float64,0x8005f37d810be6fc,0x8005f37d810be6fc,2
+np.float64,0x800715b081ae2b62,0x800715b081ae2b62,2
+np.float64,0x3fef94c35bff2986,0x3ff27b4bed2f4051,2
+np.float64,0x6f5798e0deb0,0x6f5798e0deb0,2
+np.float64,0x3fcef1f05c3de3e1,0x3fcf3f557550598f,2
+np.float64,0xbf9a91c400352380,0xbf9a92876273b85c,2
+np.float64,0x3fc9143f7f322880,0x3fc93d678c05d26b,2
+np.float64,0x78ad847af15b1,0x78ad847af15b1,2
+np.float64,0x8000fdc088c1fb82,0x8000fdc088c1fb82,2
+np.float64,0x800200fd304401fb,0x800200fd304401fb,2
+np.float64,0x7fb8ab09dc315613,0x7ff0000000000000,2
+np.float64,0x3fe949771b7292ee,0x3fec00891c3fc5a2,2
+np.float64,0xbfc54cae0e2a995c,0xbfc565e0f3d0e3af,2
+np.float64,0xffd546161e2a8c2c,0xfff0000000000000,2
+np.float64,0x800fe1d1279fc3a2,0x800fe1d1279fc3a2,2
+np.float64,0x3fd9c45301b388a8,0x3fda77fa1f4c79bf,2
+np.float64,0x7fe10ff238221fe3,0x7ff0000000000000,2
+np.float64,0xbfbc2181ae384300,0xbfbc3002229155c4,2
+np.float64,0xbfe7bbfae4ef77f6,0xbfe9f895e91f468d,2
+np.float64,0x800d3d994f7a7b33,0x800d3d994f7a7b33,2
+np.float64,0xffe6e15a896dc2b4,0xfff0000000000000,2
+np.float64,0x800e6b6c8abcd6d9,0x800e6b6c8abcd6d9,2
+np.float64,0xbfd862c938b0c592,0xbfd8faf1cdcb09db,2
+np.float64,0xffe2411f8464823e,0xfff0000000000000,2
+np.float64,0xffd0b32efaa1665e,0xfff0000000000000,2
+np.float64,0x3ac4ace475896,0x3ac4ace475896,2
+np.float64,0xf9c3a7ebf3875,0xf9c3a7ebf3875,2
+np.float64,0xdb998ba5b7332,0xdb998ba5b7332,2
+np.float64,0xbfe438a14fe87142,0xbfe5981751e4c5cd,2
+np.float64,0xbfbcf48cbc39e918,0xbfbd045d60e65d3a,2
+np.float64,0x7fde499615bc932b,0x7ff0000000000000,2
+np.float64,0x800bba269057744e,0x800bba269057744e,2
+np.float64,0x3fc9bb1ba3337638,0x3fc9e78fdb6799c1,2
+np.float64,0xffd9f974fbb3f2ea,0xfff0000000000000,2
+np.float64,0x7fcf1ad1693e35a2,0x7ff0000000000000,2
+np.float64,0x7fe5dcedd32bb9db,0x7ff0000000000000,2
+np.float64,0xeb06500bd60ca,0xeb06500bd60ca,2
+np.float64,0x7fd73e7b592e7cf6,0x7ff0000000000000,2
+np.float64,0xbfe9d91ae873b236,0xbfecc08482849bcd,2
+np.float64,0xffc85338b730a670,0xfff0000000000000,2
+np.float64,0x7fbba41eee37483d,0x7ff0000000000000,2
+np.float64,0x3fed5624fb7aac4a,0x3ff0cf9f0de1fd54,2
+np.float64,0xffe566d80d6acdb0,0xfff0000000000000,2
+np.float64,0x3fd4477884a88ef1,0x3fd49ec7acdd25a0,2
+np.float64,0x3fcb98c5fd37318c,0x3fcbcfa20e2c2712,2
+np.float64,0xffdeba71d5bd74e4,0xfff0000000000000,2
+np.float64,0x8001edc59dc3db8c,0x8001edc59dc3db8c,2
+np.float64,0x3fe6b09e896d613e,0x3fe8a3bb541ec0e3,2
+np.float64,0x3fe8694b4970d296,0x3fead94d271d05cf,2
+np.float64,0xb52c27bf6a585,0xb52c27bf6a585,2
+np.float64,0x7fcb0a21d9361443,0x7ff0000000000000,2
+np.float64,0xbfd9efc68cb3df8e,0xbfdaa7058c0ccbd1,2
+np.float64,0x8007cd170fef9a2f,0x8007cd170fef9a2f,2
+np.float64,0x3fe83325e770664c,0x3fea92c55c9d567e,2
+np.float64,0x800bd0085537a011,0x800bd0085537a011,2
+np.float64,0xffe05b9e7820b73c,0xfff0000000000000,2
+np.float64,0x3fea4ce4347499c8,0x3fed5cea9fdc541b,2
+np.float64,0x7fe08aae1921155b,0x7ff0000000000000,2
+np.float64,0x3fe7a5e7deef4bd0,0x3fe9dc2e20cfb61c,2
+np.float64,0xbfe0ccc8e6e19992,0xbfe195175f32ee3f,2
+np.float64,0xbfe8649717f0c92e,0xbfead3298974dcf0,2
+np.float64,0x7fed6c5308bad8a5,0x7ff0000000000000,2
+np.float64,0xffdbd8c7af37b190,0xfff0000000000000,2
+np.float64,0xbfb2bc4d06257898,0xbfb2c09569912839,2
+np.float64,0x3fc62eca512c5d95,0x3fc64b4251bce8f9,2
+np.float64,0xbfcae2ddbd35c5bc,0xbfcb15971fc61312,2
+np.float64,0x18d26ce831a4f,0x18d26ce831a4f,2
+np.float64,0x7fe38b279267164e,0x7ff0000000000000,2
+np.float64,0x97e1d9ab2fc3b,0x97e1d9ab2fc3b,2
+np.float64,0xbfee8e4785fd1c8f,0xbff1b52d16807627,2
+np.float64,0xbfb189b4a6231368,0xbfb18d37e83860ee,2
+np.float64,0xffd435761ea86aec,0xfff0000000000000,2
+np.float64,0x3fe6c48ebced891e,0x3fe8bcea189c3867,2
+np.float64,0x7fdadd3678b5ba6c,0x7ff0000000000000,2
+np.float64,0x7fea8f15b7b51e2a,0x7ff0000000000000,2
+np.float64,0xbff0000000000000,0xbff2cd9fc44eb982,2
+np.float64,0x80004c071120980f,0x80004c071120980f,2
+np.float64,0x8005367adfea6cf6,0x8005367adfea6cf6,2
+np.float64,0x3fbdc9139a3b9220,0x3fbdda4aba667ce5,2
+np.float64,0x7fed5ee3ad7abdc6,0x7ff0000000000000,2
+np.float64,0x51563fb2a2ac9,0x51563fb2a2ac9,2
+np.float64,0xbfba7d26ce34fa50,0xbfba894229c50ea1,2
+np.float64,0x6c10db36d821c,0x6c10db36d821c,2
+np.float64,0xbfbdaec0d03b5d80,0xbfbdbfca6ede64f4,2
+np.float64,0x800a1cbe7414397d,0x800a1cbe7414397d,2
+np.float64,0x800ae6e7f2d5cdd0,0x800ae6e7f2d5cdd0,2
+np.float64,0x3fea63d3fef4c7a8,0x3fed7c1356688ddc,2
+np.float64,0xbfde1e3a88bc3c76,0xbfdf3dfb09cc2260,2
+np.float64,0xbfd082d75a2105ae,0xbfd0b1e28c84877b,2
+np.float64,0x7fea1e5e85f43cbc,0x7ff0000000000000,2
+np.float64,0xffe2237a1a6446f4,0xfff0000000000000,2
+np.float64,0x3fd1e2be8523c57d,0x3fd21e93dfd1bbc4,2
+np.float64,0x3fd1acd428a359a8,0x3fd1e6916a42bc3a,2
+np.float64,0x61a152f0c342b,0x61a152f0c342b,2
+np.float64,0xbfc61a6b902c34d8,0xbfc6369557690ba0,2
+np.float64,0x7fd1a84b1f235095,0x7ff0000000000000,2
+np.float64,0x1c5cc7e638b9a,0x1c5cc7e638b9a,2
+np.float64,0x8008039755f0072f,0x8008039755f0072f,2
+np.float64,0x80097532d6f2ea66,0x80097532d6f2ea66,2
+np.float64,0xbfc6d979a12db2f4,0xbfc6f89777c53f8f,2
+np.float64,0x8004293ab1085276,0x8004293ab1085276,2
+np.float64,0x3fc2af5c21255eb8,0x3fc2c05dc0652554,2
+np.float64,0xbfd9a5ab87b34b58,0xbfda56d1076abc98,2
+np.float64,0xbfebd360ba77a6c2,0xbfef779fd6595f9b,2
+np.float64,0xffd5313c43aa6278,0xfff0000000000000,2
+np.float64,0xbfe994a262b32945,0xbfec64b969852ed5,2
+np.float64,0x3fce01a52e3c034a,0x3fce48324eb29c31,2
+np.float64,0x56bd74b2ad7af,0x56bd74b2ad7af,2
+np.float64,0xb84093ff70813,0xb84093ff70813,2
+np.float64,0x7fe776df946eedbe,0x7ff0000000000000,2
+np.float64,0xbfe294ac2e652958,0xbfe3a480938afa26,2
+np.float64,0x7fe741b4d0ee8369,0x7ff0000000000000,2
+np.float64,0x800b7e8a1056fd15,0x800b7e8a1056fd15,2
+np.float64,0x7fd28f1269251e24,0x7ff0000000000000,2
+np.float64,0x8009d4492e73a893,0x8009d4492e73a893,2
+np.float64,0x3fe3f27fca67e500,0x3fe543aff825e244,2
+np.float64,0x3fd12447e5a24890,0x3fd158efe43c0452,2
+np.float64,0xbfd58df0f2ab1be2,0xbfd5f6d908e3ebce,2
+np.float64,0xffc0a8e4642151c8,0xfff0000000000000,2
+np.float64,0xbfedb197787b632f,0xbff112367ec9d3e7,2
+np.float64,0xffdde07a7f3bc0f4,0xfff0000000000000,2
+np.float64,0x3fe91f3e5b723e7d,0x3febc886a1d48364,2
+np.float64,0x3fe50415236a082a,0x3fe68f43a5468d8c,2
+np.float64,0xd9a0c875b3419,0xd9a0c875b3419,2
+np.float64,0xbfee04ccf4bc099a,0xbff14f4740a114cf,2
+np.float64,0xbfd2bcc6a125798e,0xbfd30198b1e7d7ed,2
+np.float64,0xbfeb3c16f8f6782e,0xbfeea4ce47d09f58,2
+np.float64,0xffd3ba19e4a77434,0xfff0000000000000,2
+np.float64,0x8010000000000000,0x8010000000000000,2
+np.float64,0x3fdef0a642bde14d,0x3fe0146677b3a488,2
+np.float64,0x3fdc3dd0a2b87ba0,0x3fdd2abe65651487,2
+np.float64,0x3fdbb1fd47b763fb,0x3fdc915a2fd19f4b,2
+np.float64,0x7fbaa375e63546eb,0x7ff0000000000000,2
+np.float64,0x433ef8ee867e0,0x433ef8ee867e0,2
+np.float64,0xf5345475ea68b,0xf5345475ea68b,2
+np.float64,0xa126419b424c8,0xa126419b424c8,2
+np.float64,0x3fe0057248200ae5,0x3fe0b2f488339709,2
+np.float64,0xffc5e3b82f2bc770,0xfff0000000000000,2
+np.float64,0xffb215c910242b90,0xfff0000000000000,2
+np.float64,0xbfeba4ae0837495c,0xbfef3642e4b54aac,2
+np.float64,0xffbb187ebe363100,0xfff0000000000000,2
+np.float64,0x3fe4c6a496a98d49,0x3fe64440cdf06aab,2
+np.float64,0x800767a28f6ecf46,0x800767a28f6ecf46,2
+np.float64,0x3fdbed63b1b7dac8,0x3fdcd27318c0b683,2
+np.float64,0x80006d8339e0db07,0x80006d8339e0db07,2
+np.float64,0x8000b504f0416a0b,0x8000b504f0416a0b,2
+np.float64,0xbfe88055bfb100ac,0xbfeaf767bd2767b9,2
+np.float64,0x3fefe503317fca06,0x3ff2b8d4057240c8,2
+np.float64,0x7fe307538b660ea6,0x7ff0000000000000,2
+np.float64,0x944963c12892d,0x944963c12892d,2
+np.float64,0xbfd2c20b38a58416,0xbfd30717900f8233,2
+np.float64,0x7feed04e3e3da09b,0x7ff0000000000000,2
+np.float64,0x3fe639619cac72c3,0x3fe80de7b8560a8d,2
+np.float64,0x3fde066c66bc0cd9,0x3fdf237fb759a652,2
+np.float64,0xbfc56b22b52ad644,0xbfc584c267a47ebd,2
+np.float64,0x3fc710d5b12e21ab,0x3fc730d817ba0d0c,2
+np.float64,0x3fee1dfc347c3bf8,0x3ff161d9c3e15f68,2
+np.float64,0x3fde400954bc8013,0x3fdf639e5cc9e7a9,2
+np.float64,0x56e701f8adce1,0x56e701f8adce1,2
+np.float64,0xbfe33bbc89e67779,0xbfe46996b39381fe,2
+np.float64,0x7fec89e2f87913c5,0x7ff0000000000000,2
+np.float64,0xbfdad58b40b5ab16,0xbfdba098cc0ad5d3,2
+np.float64,0x3fe99c76a13338ed,0x3fec6f31bae613e7,2
+np.float64,0x3fe4242a29a84854,0x3fe57f6b45e5c0ef,2
+np.float64,0xbfe79d3199ef3a63,0xbfe9d0fb96c846ba,2
+np.float64,0x7ff8000000000000,0x7ff8000000000000,2
+np.float64,0xbfeb35a6cf766b4e,0xbfee9be4e7e943f7,2
+np.float64,0x3e047f267c091,0x3e047f267c091,2
+np.float64,0x4bf1376a97e28,0x4bf1376a97e28,2
+np.float64,0x800ef419685de833,0x800ef419685de833,2
+np.float64,0x3fe0efa61a21df4c,0x3fe1bce98baf2f0f,2
+np.float64,0x3fcc13c4d738278a,0x3fcc4d8c778bcaf7,2
+np.float64,0x800f1d291afe3a52,0x800f1d291afe3a52,2
+np.float64,0x3fd3f10e6da7e21d,0x3fd444106761ea1d,2
+np.float64,0x800706d6d76e0dae,0x800706d6d76e0dae,2
+np.float64,0xffa1ffbc9023ff80,0xfff0000000000000,2
+np.float64,0xbfe098f26d6131e5,0xbfe15a08a5f3eac0,2
+np.float64,0x3fe984f9cc7309f4,0x3fec4fcdbdb1cb9b,2
+np.float64,0x7fd7c2f1eaaf85e3,0x7ff0000000000000,2
+np.float64,0x800a8adb64f515b7,0x800a8adb64f515b7,2
+np.float64,0x80060d3ffc8c1a81,0x80060d3ffc8c1a81,2
+np.float64,0xbfec37e4aef86fc9,0xbff0029a6a1d61e2,2
+np.float64,0x800b21bcfcf6437a,0x800b21bcfcf6437a,2
+np.float64,0xbfc08facc1211f58,0xbfc09b8380ea8032,2
+np.float64,0xffebb4b52577696a,0xfff0000000000000,2
+np.float64,0x800b08096df61013,0x800b08096df61013,2
+np.float64,0x8000000000000000,0x8000000000000000,2
+np.float64,0xffd2f0c9c8a5e194,0xfff0000000000000,2
+np.float64,0xffe78b2299af1644,0xfff0000000000000,2
+np.float64,0x7fd0444794a0888e,0x7ff0000000000000,2
+np.float64,0x307c47b460f8a,0x307c47b460f8a,2
+np.float64,0xffe6b4c851ad6990,0xfff0000000000000,2
+np.float64,0xffe1877224a30ee4,0xfff0000000000000,2
+np.float64,0x48d7b5c091af7,0x48d7b5c091af7,2
+np.float64,0xbfa1dc6b1c23b8d0,0xbfa1dd5889e1b7da,2
+np.float64,0x3fe5004737ea008e,0x3fe68a9c310b08c1,2
+np.float64,0x7fec5f0742b8be0e,0x7ff0000000000000,2
+np.float64,0x3fd0a86285a150c5,0x3fd0d8b238d557fa,2
+np.float64,0x7fed60380efac06f,0x7ff0000000000000,2
+np.float64,0xeeca74dfdd94f,0xeeca74dfdd94f,2
+np.float64,0x3fda05aaa8b40b54,0x3fdabebdbf405e84,2
+np.float64,0x800e530ceb1ca61a,0x800e530ceb1ca61a,2
+np.float64,0x800b3866379670cd,0x800b3866379670cd,2
+np.float64,0xffedb3e7fa3b67cf,0xfff0000000000000,2
+np.float64,0xffdfa4c0713f4980,0xfff0000000000000,2
+np.float64,0x7fe4679e0728cf3b,0x7ff0000000000000,2
+np.float64,0xffe978611ef2f0c2,0xfff0000000000000,2
+np.float64,0x7fc9f4601f33e8bf,0x7ff0000000000000,2
+np.float64,0x3fd4942de6a9285c,0x3fd4ef6e089357dd,2
+np.float64,0x3faafe064435fc00,0x3fab0139cd6564dc,2
+np.float64,0x800d145a519a28b5,0x800d145a519a28b5,2
+np.float64,0xbfd82636f2304c6e,0xbfd8b9f75ddd2f02,2
+np.float64,0xbfdf2e975e3e5d2e,0xbfe037174280788c,2
+np.float64,0x7fd7051d7c2e0a3a,0x7ff0000000000000,2
+np.float64,0x8007933d452f267b,0x8007933d452f267b,2
+np.float64,0xb2043beb64088,0xb2043beb64088,2
+np.float64,0x3febfd9708f7fb2e,0x3fefb2ef090f18d2,2
+np.float64,0xffd9bc6bc83378d8,0xfff0000000000000,2
+np.float64,0xc10f9fd3821f4,0xc10f9fd3821f4,2
+np.float64,0x3fe3c83413a79068,0x3fe510fa1dd8edf7,2
+np.float64,0x3fbe26ccda3c4da0,0x3fbe38a892279975,2
+np.float64,0x3fcc1873103830e6,0x3fcc5257a6ae168d,2
+np.float64,0xe7e000e9cfc00,0xe7e000e9cfc00,2
+np.float64,0xffda73852bb4e70a,0xfff0000000000000,2
+np.float64,0xbfe831be19f0637c,0xbfea90f1b34da3e5,2
+np.float64,0xbfeb568f3076ad1e,0xbfeec97eebfde862,2
+np.float64,0x510a6ad0a214e,0x510a6ad0a214e,2
+np.float64,0x3fe6ba7e35ed74fc,0x3fe8b032a9a28c6a,2
+np.float64,0xffeb5cdcff76b9b9,0xfff0000000000000,2
+np.float64,0x4f0a23e89e145,0x4f0a23e89e145,2
+np.float64,0x446ec20288dd9,0x446ec20288dd9,2
+np.float64,0x7fe2521b02e4a435,0x7ff0000000000000,2
+np.float64,0x8001cd2969e39a54,0x8001cd2969e39a54,2
+np.float64,0x3fdfe90600bfd20c,0x3fe09fdcca10001c,2
+np.float64,0x7fd660c5762cc18a,0x7ff0000000000000,2
+np.float64,0xbfb11b23aa223648,0xbfb11e661949b377,2
+np.float64,0x800e025285fc04a5,0x800e025285fc04a5,2
+np.float64,0xffb180bb18230178,0xfff0000000000000,2
+np.float64,0xaaf590df55eb2,0xaaf590df55eb2,2
+np.float64,0xbfe8637d9df0c6fb,0xbfead1ba429462ec,2
+np.float64,0x7fd2577866a4aef0,0x7ff0000000000000,2
+np.float64,0xbfcfb2ab5a3f6558,0xbfd002ee87f272b9,2
+np.float64,0x7fdd64ae2f3ac95b,0x7ff0000000000000,2
+np.float64,0xffd1a502c9234a06,0xfff0000000000000,2
+np.float64,0x7fc4be4b60297c96,0x7ff0000000000000,2
+np.float64,0xbfb46b712a28d6e0,0xbfb470fca9919172,2
+np.float64,0xffdef913033df226,0xfff0000000000000,2
+np.float64,0x3fd94a3545b2946b,0x3fd9f40431ce9f9c,2
+np.float64,0x7fef88a0b6ff1140,0x7ff0000000000000,2
+np.float64,0xbfbcc81876399030,0xbfbcd7a0ab6cb388,2
+np.float64,0x800a4acfdd9495a0,0x800a4acfdd9495a0,2
+np.float64,0xffe270b3d5e4e167,0xfff0000000000000,2
+np.float64,0xbfd23f601e247ec0,0xbfd27eeca50a49eb,2
+np.float64,0x7fec6e796a78dcf2,0x7ff0000000000000,2
+np.float64,0x3fb85e0c9630bc19,0x3fb867791ccd6c72,2
+np.float64,0x7fe49fc424a93f87,0x7ff0000000000000,2
+np.float64,0xbfe75a99fbaeb534,0xbfe97ba37663de4c,2
+np.float64,0xffe85011b630a023,0xfff0000000000000,2
+np.float64,0xffe5962e492b2c5c,0xfff0000000000000,2
+np.float64,0x6f36ed4cde6de,0x6f36ed4cde6de,2
+np.float64,0x3feb72170af6e42e,0x3feeefbe6f1a2084,2
+np.float64,0x80014d8d60629b1c,0x80014d8d60629b1c,2
+np.float64,0xbfe0eb40d321d682,0xbfe1b7e31f252bf1,2
+np.float64,0x31fe305663fc7,0x31fe305663fc7,2
+np.float64,0x3fd2cd6381a59ac7,0x3fd312edc9868a4d,2
+np.float64,0xffcf0720793e0e40,0xfff0000000000000,2
+np.float64,0xbfeef1ef133de3de,0xbff1ffd5e1a3b648,2
+np.float64,0xbfd01c787aa038f0,0xbfd0482be3158a01,2
+np.float64,0x3fda3607c5b46c10,0x3fdaf3301e217301,2
+np.float64,0xffda9a9911b53532,0xfff0000000000000,2
+np.float64,0x3fc0b37c392166f8,0x3fc0bfa076f3c43e,2
+np.float64,0xbfe06591c760cb24,0xbfe11fad179ea12c,2
+np.float64,0x8006e369c20dc6d4,0x8006e369c20dc6d4,2
+np.float64,0x3fdf2912a8be5224,0x3fe033ff74b92f4d,2
+np.float64,0xffc0feb07821fd60,0xfff0000000000000,2
+np.float64,0xa4b938c949727,0xa4b938c949727,2
+np.float64,0x8008fe676571fccf,0x8008fe676571fccf,2
+np.float64,0xbfdda68459bb4d08,0xbfdeb8faab34fcbc,2
+np.float64,0xbfda18b419343168,0xbfdad360ca52ec7c,2
+np.float64,0x3febcbae35b7975c,0x3fef6cd51c9ebc15,2
+np.float64,0x3fbec615f63d8c30,0x3fbed912ba729926,2
+np.float64,0x7f99a831c8335063,0x7ff0000000000000,2
+np.float64,0x3fe663e8826cc7d1,0x3fe84330bd9aada8,2
+np.float64,0x70a9f9e6e1540,0x70a9f9e6e1540,2
+np.float64,0x8a13a5db14275,0x8a13a5db14275,2
+np.float64,0x7fc4330a3b286613,0x7ff0000000000000,2
+np.float64,0xbfe580c6136b018c,0xbfe728806cc7a99a,2
+np.float64,0x8000000000000001,0x8000000000000001,2
+np.float64,0xffec079d5df80f3a,0xfff0000000000000,2
+np.float64,0x8e1173c31c22f,0x8e1173c31c22f,2
+np.float64,0x3fe088456d21108b,0x3fe14712ca414103,2
+np.float64,0x3fe1b76f73636edf,0x3fe2a2b658557112,2
+np.float64,0xbfd4a1dd162943ba,0xbfd4fdd45cae8fb8,2
+np.float64,0x7fd60b46c8ac168d,0x7ff0000000000000,2
+np.float64,0xffe36cc3b166d987,0xfff0000000000000,2
+np.float64,0x3fdc2ae0cfb855c0,0x3fdd15f026773151,2
+np.float64,0xbfc41aa203283544,0xbfc42fd1b145fdd5,2
+np.float64,0xffed90c55fbb218a,0xfff0000000000000,2
+np.float64,0x3fe67e3a9aecfc75,0x3fe86440db65b4f6,2
+np.float64,0x7fd12dbeaba25b7c,0x7ff0000000000000,2
+np.float64,0xbfe1267c0de24cf8,0xbfe1fbb611bdf1e9,2
+np.float64,0x22e5619645cad,0x22e5619645cad,2
+np.float64,0x7fe327c72ea64f8d,0x7ff0000000000000,2
+np.float64,0x7fd2c3f545a587ea,0x7ff0000000000000,2
+np.float64,0x7fc7b689372f6d11,0x7ff0000000000000,2
+np.float64,0xc5e140bd8bc28,0xc5e140bd8bc28,2
+np.float64,0x3fccb3627a3966c5,0x3fccf11b44fa4102,2
+np.float64,0xbfd2cf725c259ee4,0xbfd315138d0e5dca,2
+np.float64,0x10000000000000,0x10000000000000,2
+np.float64,0xbfd3dfa8b627bf52,0xbfd431d17b235477,2
+np.float64,0xbfb82124e6304248,0xbfb82a4b6d9c2663,2
+np.float64,0x3fdcd590d9b9ab22,0x3fddd1d548806347,2
+np.float64,0x7fdee0cd1b3dc199,0x7ff0000000000000,2
+np.float64,0x8004ebfc60a9d7fa,0x8004ebfc60a9d7fa,2
+np.float64,0x3fe8eb818b71d704,0x3feb842679806108,2
+np.float64,0xffdd5e8fe63abd20,0xfff0000000000000,2
+np.float64,0xbfe3efcbd9e7df98,0xbfe54071436645ee,2
+np.float64,0x3fd5102557aa204b,0x3fd57203d31a05b8,2
+np.float64,0x3fe6318af7ec6316,0x3fe8041a177cbf96,2
+np.float64,0x3fdf3cecdabe79da,0x3fe03f2084ffbc78,2
+np.float64,0x7fe0ab6673a156cc,0x7ff0000000000000,2
+np.float64,0x800037d5c6c06fac,0x800037d5c6c06fac,2
+np.float64,0xffce58b86a3cb170,0xfff0000000000000,2
+np.float64,0xbfe3455d6ce68abb,0xbfe475034cecb2b8,2
+np.float64,0x991b663d3236d,0x991b663d3236d,2
+np.float64,0x3fda82d37c3505a7,0x3fdb46973da05c12,2
+np.float64,0x3f9b736fa036e6df,0x3f9b74471c234411,2
+np.float64,0x8001c96525e392cb,0x8001c96525e392cb,2
+np.float64,0x7ff0000000000000,0x7ff0000000000000,2
+np.float64,0xbfaf59122c3eb220,0xbfaf5e15f8b272b0,2
+np.float64,0xbf9aa7d288354fa0,0xbf9aa897d2a40cb5,2
+np.float64,0x8004a43428694869,0x8004a43428694869,2
+np.float64,0x7feead476dbd5a8e,0x7ff0000000000000,2
+np.float64,0xffca150f81342a20,0xfff0000000000000,2
+np.float64,0x80047ec3bc88fd88,0x80047ec3bc88fd88,2
+np.float64,0xbfee3e5b123c7cb6,0xbff179c8b8334278,2
+np.float64,0x3fd172359f22e46b,0x3fd1a9ba6b1420a1,2
+np.float64,0x3fe8e5e242f1cbc5,0x3feb7cbcaefc4d5c,2
+np.float64,0x8007fb059a6ff60c,0x8007fb059a6ff60c,2
+np.float64,0xe3899e71c7134,0xe3899e71c7134,2
+np.float64,0x7fe3b98326a77305,0x7ff0000000000000,2
+np.float64,0x7fec4e206cb89c40,0x7ff0000000000000,2
+np.float64,0xbfa3b012c4276020,0xbfa3b150c13b3cc5,2
+np.float64,0xffefffffffffffff,0xfff0000000000000,2
+np.float64,0xffe28a5b9aa514b6,0xfff0000000000000,2
+np.float64,0xbfd76a6cc2aed4da,0xbfd7f10f4d04e7f6,2
+np.float64,0xbc2b1c0178564,0xbc2b1c0178564,2
+np.float64,0x6d9d444adb3a9,0x6d9d444adb3a9,2
+np.float64,0xbfdcadd368395ba6,0xbfdda6037b5c429c,2
+np.float64,0x3fe11891fde23124,0x3fe1ebc1c204b14b,2
+np.float64,0x3fdd66c3eebacd88,0x3fde72526b5304c4,2
+np.float64,0xbfe79d85612f3b0b,0xbfe9d1673bd1f6d6,2
+np.float64,0x3fed60abdabac158,0x3ff0d7426b3800a2,2
+np.float64,0xbfb0ffa54021ff48,0xbfb102d81073a9f0,2
+np.float64,0xd2452af5a48a6,0xd2452af5a48a6,2
+np.float64,0xf4b835c1e971,0xf4b835c1e971,2
+np.float64,0x7e269cdafc4d4,0x7e269cdafc4d4,2
+np.float64,0x800097a21d812f45,0x800097a21d812f45,2
+np.float64,0x3fdfcc85e8bf990c,0x3fe08fcf770fd456,2
+np.float64,0xd8d53155b1aa6,0xd8d53155b1aa6,2
+np.float64,0x7fb8ed658831daca,0x7ff0000000000000,2
+np.float64,0xbfec865415b90ca8,0xbff03a4584d719f9,2
+np.float64,0xffd8cda62a319b4c,0xfff0000000000000,2
+np.float64,0x273598d84e6b4,0x273598d84e6b4,2
+np.float64,0x7fd566b5c32acd6b,0x7ff0000000000000,2
+np.float64,0xff61d9d48023b400,0xfff0000000000000,2
+np.float64,0xbfec5c3bf4f8b878,0xbff01c594243337c,2
+np.float64,0x7fd1be0561a37c0a,0x7ff0000000000000,2
+np.float64,0xffeaee3271b5dc64,0xfff0000000000000,2
+np.float64,0x800c0e1931b81c33,0x800c0e1931b81c33,2
+np.float64,0xbfad1171583a22e0,0xbfad1570e5c466d2,2
+np.float64,0x7fd783b0fe2f0761,0x7ff0000000000000,2
+np.float64,0x7fc39903e6273207,0x7ff0000000000000,2
+np.float64,0xffe00003c5600007,0xfff0000000000000,2
+np.float64,0x35a7b9c06b50,0x35a7b9c06b50,2
+np.float64,0x7fee441a22bc8833,0x7ff0000000000000,2
+np.float64,0xff6e47fbc03c9000,0xfff0000000000000,2
+np.float64,0xbfd3c3c9c8a78794,0xbfd41499b1912534,2
+np.float64,0x82c9c87f05939,0x82c9c87f05939,2
+np.float64,0xbfedeb0fe4fbd620,0xbff13c573ce9d3d0,2
+np.float64,0x2b79298656f26,0x2b79298656f26,2
+np.float64,0xbf5ee44f003dc800,0xbf5ee4503353c0ba,2
+np.float64,0xbfe1dd264e63ba4c,0xbfe2ce68116c7bf6,2
+np.float64,0x3fece10b7579c217,0x3ff07b21b11799c6,2
+np.float64,0x3fba47143a348e28,0x3fba52e601adf24c,2
+np.float64,0xffe9816e7a7302dc,0xfff0000000000000,2
+np.float64,0x8009a8047fd35009,0x8009a8047fd35009,2
+np.float64,0x800ac28e4e95851d,0x800ac28e4e95851d,2
+np.float64,0x80093facf4f27f5a,0x80093facf4f27f5a,2
+np.float64,0x3ff0000000000000,0x3ff2cd9fc44eb982,2
+np.float64,0x3fe76a9857eed530,0x3fe99018a5895a4f,2
+np.float64,0xbfd13c59a3a278b4,0xbfd171e133df0b16,2
+np.float64,0x7feb43bc83368778,0x7ff0000000000000,2
+np.float64,0xbfe2970c5fa52e18,0xbfe3a74a434c6efe,2
+np.float64,0xffd091c380212388,0xfff0000000000000,2
+np.float64,0x3febb3b9d2f76774,0x3fef4b4af2bd8580,2
+np.float64,0x7fec66787ef8ccf0,0x7ff0000000000000,2
+np.float64,0xbf935e185826bc40,0xbf935e640557a354,2
+np.float64,0x979df1552f3be,0x979df1552f3be,2
+np.float64,0x7fc096ee73212ddc,0x7ff0000000000000,2
+np.float64,0xbfe9de88faf3bd12,0xbfecc7d1ae691d1b,2
+np.float64,0x7fdc733f06b8e67d,0x7ff0000000000000,2
+np.float64,0xffd71be1a0ae37c4,0xfff0000000000000,2
+np.float64,0xb50dabd36a1b6,0xb50dabd36a1b6,2
+np.float64,0x7fce3d94d63c7b29,0x7ff0000000000000,2
+np.float64,0x7fbaf95e4435f2bc,0x7ff0000000000000,2
+np.float64,0x81a32a6f03466,0x81a32a6f03466,2
+np.float64,0xa99b5b4d5336c,0xa99b5b4d5336c,2
+np.float64,0x7f97c1eeb82f83dc,0x7ff0000000000000,2
+np.float64,0x3fe761636d6ec2c6,0x3fe98451160d2ffb,2
+np.float64,0xbfe3224ef5e6449e,0xbfe44b73eeadac52,2
+np.float64,0x7fde6feb0dbcdfd5,0x7ff0000000000000,2
+np.float64,0xbfee87f9ca7d0ff4,0xbff1b079e9d7f706,2
+np.float64,0x3fe46f4c9828de99,0x3fe5da2ab9609ea5,2
+np.float64,0xffb92fe882325fd0,0xfff0000000000000,2
+np.float64,0x80054bc63cea978d,0x80054bc63cea978d,2
+np.float64,0x3d988bea7b312,0x3d988bea7b312,2
+np.float64,0x3fe6468e1d6c8d1c,0x3fe81e64d37d39a8,2
+np.float64,0x3fd68eefc22d1de0,0x3fd7074264faeead,2
+np.float64,0xffb218a074243140,0xfff0000000000000,2
+np.float64,0x3fdbcb3b6cb79678,0x3fdcad011de40b7d,2
+np.float64,0x7fe3c161772782c2,0x7ff0000000000000,2
+np.float64,0x25575c904aaec,0x25575c904aaec,2
+np.float64,0x800fa43a8f5f4875,0x800fa43a8f5f4875,2
+np.float64,0x3fe41fc9e1e83f94,0x3fe57a25dd1a37f1,2
+np.float64,0x3fd895f4a7b12be9,0x3fd931e7b721a08a,2
+np.float64,0xce31469f9c629,0xce31469f9c629,2
+np.float64,0xffea0f55ca341eab,0xfff0000000000000,2
+np.float64,0xffe831c9ba306393,0xfff0000000000000,2
+np.float64,0x7fe2056f03a40add,0x7ff0000000000000,2
+np.float64,0x7fd6b075e02d60eb,0x7ff0000000000000,2
+np.float64,0x3fdfbef4273f7de8,0x3fe0882c1f59efc0,2
+np.float64,0x8005b9e094ab73c2,0x8005b9e094ab73c2,2
+np.float64,0x3fea881ac6351036,0x3fedad7a319b887c,2
+np.float64,0xbfe2c61c7ee58c39,0xbfe3de9a99d8a9c6,2
+np.float64,0x30b0d3786161b,0x30b0d3786161b,2
+np.float64,0x3fa51d56a02a3aad,0x3fa51edee2d2ecef,2
+np.float64,0x79745732f2e8c,0x79745732f2e8c,2
+np.float64,0x800d55b4907aab69,0x800d55b4907aab69,2
+np.float64,0xbfbe8fcf0a3d1fa0,0xbfbea267fbb5bfdf,2
+np.float64,0xbfd04e2756a09c4e,0xbfd07b74d079f9a2,2
+np.float64,0x3fc65170552ca2e1,0x3fc66e6eb00c82ed,2
+np.float64,0xbfb0674b8020ce98,0xbfb06a2b4771b64c,2
+np.float64,0x2059975840b34,0x2059975840b34,2
+np.float64,0x33d1385467a28,0x33d1385467a28,2
+np.float64,0x3fea41b74ff4836f,0x3fed4dc1a09e53cc,2
+np.float64,0xbfe8e08c9d71c119,0xbfeb75b4c59a6bec,2
+np.float64,0x7fdbbf14d6377e29,0x7ff0000000000000,2
+np.float64,0x3fcd8b71513b16e0,0x3fcdcec80174f9ad,2
+np.float64,0x5c50bc94b8a18,0x5c50bc94b8a18,2
+np.float64,0x969a18f52d343,0x969a18f52d343,2
+np.float64,0x3fd7ae44462f5c89,0x3fd8398bc34e395c,2
+np.float64,0xffdd0f8617ba1f0c,0xfff0000000000000,2
+np.float64,0xfff0000000000000,0xfff0000000000000,2
+np.float64,0xbfe2f9badb65f376,0xbfe41b771320ece8,2
+np.float64,0x3fd140bc7fa29,0x3fd140bc7fa29,2
+np.float64,0xbfe14523b5628a48,0xbfe21ee850972043,2
+np.float64,0x3feedd0336bdba06,0x3ff1f01afc1f3a06,2
+np.float64,0x800de423ad7bc848,0x800de423ad7bc848,2
+np.float64,0x4cef857c99df1,0x4cef857c99df1,2
+np.float64,0xbfea55e0e374abc2,0xbfed691e41d648dd,2
+np.float64,0x3fe70d7a18ae1af4,0x3fe91955a34d8094,2
+np.float64,0xbfc62fc3032c5f88,0xbfc64c3ec25decb8,2
+np.float64,0x3fc915abb5322b58,0x3fc93edac5cc73fe,2
+np.float64,0x69aaff66d3561,0x69aaff66d3561,2
+np.float64,0x5c6a90f2b8d53,0x5c6a90f2b8d53,2
+np.float64,0x3fefe30dc1bfc61c,0x3ff2b752257bdacd,2
+np.float64,0x3fef15db15fe2bb6,0x3ff21aea05601396,2
+np.float64,0xbfe353e5ac66a7cc,0xbfe48644e6553d1a,2
+np.float64,0x3fe6d30cffada61a,0x3fe8cf3e4c61ddac,2
+np.float64,0x7fb7857eb62f0afc,0x7ff0000000000000,2
+np.float64,0xbfdd9b53d23b36a8,0xbfdeac91a7af1340,2
+np.float64,0x3fd1456357228ac7,0x3fd17b3f7d39b27a,2
+np.float64,0x3fb57d10ae2afa21,0x3fb5838702b806f4,2
+np.float64,0x800c59c96c98b393,0x800c59c96c98b393,2
+np.float64,0x7fc1f2413823e481,0x7ff0000000000000,2
+np.float64,0xbfa3983624273070,0xbfa3996fa26c419a,2
+np.float64,0x7fb28874ae2510e8,0x7ff0000000000000,2
+np.float64,0x3fe826d02a304da0,0x3fea82bec50bc0b6,2
+np.float64,0x8008d6f0d3d1ade2,0x8008d6f0d3d1ade2,2
+np.float64,0xffe7c970ca2f92e1,0xfff0000000000000,2
+np.float64,0x7fcf42bcaa3e8578,0x7ff0000000000000,2
+np.float64,0x7fda1ab517343569,0x7ff0000000000000,2
+np.float64,0xbfe7926a65ef24d5,0xbfe9c323dd890d5b,2
+np.float64,0xbfcaf6282d35ec50,0xbfcb294f36a0a33d,2
+np.float64,0x800ca49df8d9493c,0x800ca49df8d9493c,2
+np.float64,0xffea18d26af431a4,0xfff0000000000000,2
+np.float64,0x3fb72f276e2e5e50,0x3fb7374539fd1221,2
+np.float64,0xffa6b613842d6c20,0xfff0000000000000,2
+np.float64,0xbfeb3c7263f678e5,0xbfeea54cdb60b54c,2
+np.float64,0x3fc976d2ba32eda5,0x3fc9a1e83a058de4,2
+np.float64,0xbfe4acd4b0e959aa,0xbfe624d5d4f9b9a6,2
+np.float64,0x7fca410a0f348213,0x7ff0000000000000,2
+np.float64,0xbfde368f77bc6d1e,0xbfdf5910c8c8bcb0,2
+np.float64,0xbfed7412937ae825,0xbff0e55afc428453,2
+np.float64,0xffef6b7b607ed6f6,0xfff0000000000000,2
+np.float64,0xbfb936f17e326de0,0xbfb941629a53c694,2
+np.float64,0x800dbb0c469b7619,0x800dbb0c469b7619,2
+np.float64,0x800f68b0581ed161,0x800f68b0581ed161,2
+np.float64,0x3fe25b2aad64b656,0x3fe361266fa9c5eb,2
+np.float64,0xbfb87e445a30fc88,0xbfb887d676910c3f,2
+np.float64,0x6e6ba9b6dcd76,0x6e6ba9b6dcd76,2
+np.float64,0x3fad27ce583a4f9d,0x3fad2bd72782ffdb,2
+np.float64,0xbfec0bc5d638178c,0xbfefc6e8c8f9095f,2
+np.float64,0x7fcba4a296374944,0x7ff0000000000000,2
+np.float64,0x8004ca237cc99448,0x8004ca237cc99448,2
+np.float64,0xffe85b8c3270b718,0xfff0000000000000,2
+np.float64,0x7fe7ee3eddafdc7d,0x7ff0000000000000,2
+np.float64,0xffd275967ca4eb2c,0xfff0000000000000,2
+np.float64,0xbfa95bc3a032b780,0xbfa95e6b288ecf43,2
+np.float64,0x3fc9e3214b33c643,0x3fca10667e7e7ff4,2
+np.float64,0x8001b89c5d837139,0x8001b89c5d837139,2
+np.float64,0xbf8807dfc0300fc0,0xbf880803e3badfbd,2
+np.float64,0x800aca94b895952a,0x800aca94b895952a,2
+np.float64,0x7fd79534a02f2a68,0x7ff0000000000000,2
+np.float64,0x3fe1b81179e37023,0x3fe2a371d8cc26f0,2
+np.float64,0x800699539d6d32a8,0x800699539d6d32a8,2
+np.float64,0xffe51dfbb3aa3bf7,0xfff0000000000000,2
+np.float64,0xbfdfb775abbf6eec,0xbfe083f48be2f98f,2
+np.float64,0x3fe87979d7b0f2f4,0x3feaee701d959079,2
+np.float64,0x3fd8e4e6a731c9cd,0x3fd986d29f25f982,2
+np.float64,0x3fe3dadaaf67b5b6,0x3fe527520fb02920,2
+np.float64,0x8003c2262bc7844d,0x8003c2262bc7844d,2
+np.float64,0x800c930add392616,0x800c930add392616,2
+np.float64,0xffb7a152a22f42a8,0xfff0000000000000,2
+np.float64,0x80028fe03dc51fc1,0x80028fe03dc51fc1,2
+np.float64,0xffe32ae60c6655cc,0xfff0000000000000,2
+np.float64,0x3fea3527e4746a50,0x3fed3cbbf47f18eb,2
+np.float64,0x800a53059e14a60c,0x800a53059e14a60c,2
+np.float64,0xbfd79e3b202f3c76,0xbfd828672381207b,2
+np.float64,0xffeed7e2eb7dafc5,0xfff0000000000000,2
+np.float64,0x3fec51ed6778a3db,0x3ff01509e34df61d,2
+np.float64,0xbfd84bc577b0978a,0xbfd8e23ec55e42e8,2
+np.float64,0x2483aff849077,0x2483aff849077,2
+np.float64,0x6f57883adeaf2,0x6f57883adeaf2,2
+np.float64,0xffd3fd74d927faea,0xfff0000000000000,2
+np.float64,0x7fca49ec773493d8,0x7ff0000000000000,2
+np.float64,0x7fd08fe2e8211fc5,0x7ff0000000000000,2
+np.float64,0x800852086db0a411,0x800852086db0a411,2
+np.float64,0x3fe5b1f2c9eb63e6,0x3fe7654f511bafc6,2
+np.float64,0xbfe01e2a58e03c54,0xbfe0cedb68f021e6,2
+np.float64,0x800988421d331085,0x800988421d331085,2
+np.float64,0xffd5038b18aa0716,0xfff0000000000000,2
+np.float64,0x8002c9264c85924d,0x8002c9264c85924d,2
+np.float64,0x3fd21ca302243946,0x3fd25ac653a71aab,2
+np.float64,0xbfea60d6e6f4c1ae,0xbfed78031d9dfa2b,2
+np.float64,0xffef97b6263f2f6b,0xfff0000000000000,2
+np.float64,0xbfd524732faa48e6,0xbfd5876ecc415dcc,2
+np.float64,0x660387e8cc072,0x660387e8cc072,2
+np.float64,0x7fcfc108a33f8210,0x7ff0000000000000,2
+np.float64,0x7febe5b0f877cb61,0x7ff0000000000000,2
+np.float64,0xbfa55fdfac2abfc0,0xbfa56176991851a8,2
+np.float64,0x25250f4c4a4a3,0x25250f4c4a4a3,2
+np.float64,0xffe2f6a2f2a5ed46,0xfff0000000000000,2
+np.float64,0x7fa754fcc02ea9f9,0x7ff0000000000000,2
+np.float64,0x3febd19dea37a33c,0x3fef75279f75d3b8,2
+np.float64,0xc5ed55218bdab,0xc5ed55218bdab,2
+np.float64,0x3fe72ff6b3ee5fed,0x3fe945388b979882,2
+np.float64,0xbfe16b854e22d70a,0xbfe24b10fc0dff14,2
+np.float64,0xffb22cbe10245980,0xfff0000000000000,2
+np.float64,0xa54246b54a849,0xa54246b54a849,2
+np.float64,0x3fe7f4cda76fe99c,0x3fea41edc74888b6,2
+np.float64,0x1,0x1,2
+np.float64,0x800d84acce9b095a,0x800d84acce9b095a,2
+np.float64,0xb0eef04761dde,0xb0eef04761dde,2
+np.float64,0x7ff4000000000000,0x7ffc000000000000,2
+np.float64,0xffecaf1dbb795e3b,0xfff0000000000000,2
+np.float64,0x90dbab8d21b76,0x90dbab8d21b76,2
+np.float64,0x3fe79584a9ef2b09,0x3fe9c71fa9e40eb5,2

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/data/umath-validation-set-tan.csv

@@ -0,0 +1,1429 @@
+dtype,input,output,ulperrortol
+np.float32,0xfd97ece0,0xc11186e9,4
+np.float32,0x8013bb34,0x8013bb34,4
+np.float32,0x316389,0x316389,4
+np.float32,0x7f7fffff,0xbf1c9eca,4
+np.float32,0x3f7674bb,0x3fb7e450,4
+np.float32,0x80800000,0x80800000,4
+np.float32,0x7f5995e8,0xbf94106c,4
+np.float32,0x74527,0x74527,4
+np.float32,0x7f08caea,0xbeceddb6,4
+np.float32,0x2d49b2,0x2d49b2,4
+np.float32,0x3f74e5e4,0x3fb58695,4
+np.float32,0x3f3fcd51,0x3f6e1e81,4
+np.float32,0xbf4f3608,0xbf864d3d,4
+np.float32,0xbed974a0,0xbee78c70,4
+np.float32,0xff5f483c,0x3ecf3cb2,4
+np.float32,0x7f4532f4,0xc0b96f7b,4
+np.float32,0x3f0a4f7c,0x3f198cc0,4
+np.float32,0x210193,0x210193,4
+np.float32,0xfeebad7a,0xbf92eba8,4
+np.float32,0xfed29f74,0xc134cab6,4
+np.float32,0x803433a0,0x803433a0,4
+np.float32,0x64eb46,0x64eb46,4
+np.float32,0xbf54ef22,0xbf8c757b,4
+np.float32,0x3f3d5fdd,0x3f69a17b,4
+np.float32,0x80000001,0x80000001,4
+np.float32,0x800a837a,0x800a837a,4
+np.float32,0x6ff0be,0x6ff0be,4
+np.float32,0xfe8f1186,0x3f518820,4
+np.float32,0x804963e5,0x804963e5,4
+np.float32,0xfebaa59a,0x3fa1dbb0,4
+np.float32,0x637970,0x637970,4
+np.float32,0x3e722a6b,0x3e76c89a,4
+np.float32,0xff2b0478,0xbddccb5f,4
+np.float32,0xbf7bd85b,0xbfc06821,4
+np.float32,0x3ec33600,0x3ecd4126,4
+np.float32,0x3e0a43b9,0x3e0b1c69,4
+np.float32,0x7f7511b6,0xbe427083,4
+np.float32,0x3f28c114,0x3f465a73,4
+np.float32,0x3f179e1c,0x3f2c3e7c,4
+np.float32,0x7b2963,0x7b2963,4
+np.float32,0x3f423d06,0x3f72b442,4
+np.float32,0x3f5a24c6,0x3f925508,4
+np.float32,0xff18c834,0xbf79b5c8,4
+np.float32,0x3f401ece,0x3f6eb6ac,4
+np.float32,0x7b8a3013,0xbffab968,4
+np.float32,0x80091ff0,0x80091ff0,4
+np.float32,0x3f389c51,0x3f610b47,4
+np.float32,0x5ea174,0x5ea174,4
+np.float32,0x807a9eb2,0x807a9eb2,4
+np.float32,0x806ce61e,0x806ce61e,4
+np.float32,0xbe956acc,0xbe99cefc,4
+np.float32,0x7e60e247,0xbf5e64a5,4
+np.float32,0x7f398e24,0x404d12ed,4
+np.float32,0x3d9049f8,0x3d908735,4
+np.float32,0x7db17ffc,0xbf5b3d87,4
+np.float32,0xff453f78,0xc0239c9f,4
+np.float32,0x3f024aac,0x3f0ed802,4
+np.float32,0xbe781c30,0xbe7d1508,4
+np.float32,0x3f77962a,0x3fb9a28e,4
+np.float32,0xff7fffff,0x3f1c9eca,4
+np.float32,0x3f7152e3,0x3fb03f9d,4
+np.float32,0xff7cb167,0x3f9ce831,4
+np.float32,0x3e763e30,0x3e7b1a10,4
+np.float32,0xbf126527,0xbf24c253,4
+np.float32,0x803f6660,0x803f6660,4
+np.float32,0xbf79de38,0xbfbd38b1,4
+np.float32,0x8046c2f0,0x8046c2f0,4
+np.float32,0x6dc74e,0x6dc74e,4
+np.float32,0xbec9c45e,0xbed4e768,4
+np.float32,0x3f0eedb6,0x3f1fe610,4
+np.float32,0x7e031999,0xbcc13026,4
+np.float32,0x7efc2fd7,0x41e4b284,4
+np.float32,0xbeab7454,0xbeb22a1b,4
+np.float32,0x805ee67b,0x805ee67b,4
+np.float32,0x7f76e58e,0xc2436659,4
+np.float32,0xbe62b024,0xbe667718,4
+np.float32,0x3eea0808,0x3efbd182,4
+np.float32,0xbf7fd00c,0xbfc70719,4
+np.float32,0x7f27b640,0xbf0d97e0,4
+np.float32,0x3f1b58a4,0x3f31b6f4,4
+np.float32,0x252a9f,0x252a9f,4
+np.float32,0x7f65f95a,0xbead5de3,4
+np.float32,0xfc6ea780,0x42d15801,4
+np.float32,0x7eac4c52,0xc0682424,4
+np.float32,0xbe8a3f5a,0xbe8db54d,4
+np.float32,0xbf1644e2,0xbf2a4abd,4
+np.float32,0x3fc96a,0x3fc96a,4
+np.float32,0x7f38c0e4,0x3cc04af8,4
+np.float32,0x3f623d75,0x3f9c065d,4
+np.float32,0x3ee6a51a,0x3ef7a058,4
+np.float32,0x3dd11020,0x3dd1cacf,4
+np.float32,0xb6918,0xb6918,4
+np.float32,0xfdd7a540,0x3f22f081,4
+np.float32,0x80798563,0x80798563,4
+np.float32,0x3e9a8b7a,0x3e9f6a7e,4
+np.float32,0xbea515d4,0xbeab0df5,4
+np.float32,0xbea9b9f4,0xbeb03abe,4
+np.float32,0xbf11a5fa,0xbf23b478,4
+np.float32,0xfd6cadf0,0xbfa2a878,4
+np.float32,0xbf6edd07,0xbfacbb78,4
+np.float32,0xff5c5328,0x3e2d1552,4
+np.float32,0xbea2f788,0xbea8b3f5,4
+np.float32,0x802efaeb,0x802efaeb,4
+np.float32,0xff1c85e5,0x41f8560e,4
+np.float32,0x3f53b123,0x3f8b18e1,4
+np.float32,0xff798c4a,0x4092e66f,4
+np.float32,0x7f2e6fe7,0xbdcbd58f,4
+np.float32,0xfe8a8196,0x3fd7fc56,4
+np.float32,0x5e7ad4,0x5e7ad4,4
+np.float32,0xbf23a02d,0xbf3e4533,4
+np.float32,0x3f31c55c,0x3f5531bf,4
+np.float32,0x80331be3,0x80331be3,4
+np.float32,0x8056960a,0x8056960a,4
+np.float32,0xff1c06ae,0xbfd26992,4
+np.float32,0xbe0cc4b0,0xbe0da96c,4
+np.float32,0x7e925ad5,0xbf8dba54,4
+np.float32,0x2c8cec,0x2c8cec,4
+np.float32,0x8011951e,0x8011951e,4
+np.float32,0x3f2caf84,0x3f4cb89f,4
+np.float32,0xbd32c220,0xbd32df33,4
+np.float32,0xbec358d6,0xbecd6996,4
+np.float32,0x3f6e4930,0x3fabeb92,4
+np.float32,0xbf6a3afd,0xbfa65a3a,4
+np.float32,0x80067764,0x80067764,4
+np.float32,0x3d8df1,0x3d8df1,4
+np.float32,0x7ee51cf2,0x409e4061,4
+np.float32,0x435f5d,0x435f5d,4
+np.float32,0xbf5b17f7,0xbf936ebe,4
+np.float32,0x3ecaacb5,0x3ed5f81f,4
+np.float32,0x807b0aa5,0x807b0aa5,4
+np.float32,0x52b40b,0x52b40b,4
+np.float32,0x146a97,0x146a97,4
+np.float32,0x7f42b952,0xbfdcb413,4
+np.float32,0xbf1a1af2,0xbf2fe1bb,4
+np.float32,0x3f312034,0x3f541aa2,4
+np.float32,0x3f281d60,0x3f4554f9,4
+np.float32,0x50e451,0x50e451,4
+np.float32,0xbe45838c,0xbe480016,4
+np.float32,0xff7d0aeb,0x3eb0746e,4
+np.float32,0x7f32a489,0xbf96af6d,4
+np.float32,0xbf1b4e27,0xbf31a769,4
+np.float32,0x3f242936,0x3f3f1a44,4
+np.float32,0xbf7482ff,0xbfb4f201,4
+np.float32,0x4bda38,0x4bda38,4
+np.float32,0xbf022208,0xbf0ea2bb,4
+np.float32,0x7d08ca95,0xbe904602,4
+np.float32,0x7ed2f356,0xc02b55ad,4
+np.float32,0xbf131204,0xbf25b734,4
+np.float32,0xff3464b4,0x3fb23706,4
+np.float32,0x5a97cf,0x5a97cf,4
+np.float32,0xbe52db70,0xbe55e388,4
+np.float32,0x3f52934f,0x3f89e2aa,4
+np.float32,0xfeea866a,0x40a2b33f,4
+np.float32,0x80333925,0x80333925,4
+np.float32,0xfef5d13e,0xc00139ec,4
+np.float32,0x3f4750ab,0x3f7c87ad,4
+np.float32,0x3e41bfdd,0x3e44185a,4
+np.float32,0xbf5b0572,0xbf935935,4
+np.float32,0xbe93c9da,0xbe9808d8,4
+np.float32,0x7f501f33,0xc0f9973c,4
+np.float32,0x800af035,0x800af035,4
+np.float32,0x3f29faf8,0x3f4852a8,4
+np.float32,0xbe1e4c20,0xbe1f920c,4
+np.float32,0xbf7e8616,0xbfc4d79d,4
+np.float32,0x43ffbf,0x43ffbf,4
+np.float32,0x7f28e8a9,0xbfa1ac24,4
+np.float32,0xbf1f9f92,0xbf3820bc,4
+np.float32,0x3f07e004,0x3f1641c4,4
+np.float32,0x3ef7ea7f,0x3f06a64a,4
+np.float32,0x7e013101,0x3f6080e6,4
+np.float32,0x7f122a4f,0xbf0a796f,4
+np.float32,0xfe096960,0x3ed7273a,4
+np.float32,0x3f06abf1,0x3f14a4b2,4
+np.float32,0x3e50ded3,0x3e53d0f1,4
+np.float32,0x7f50b346,0x3eabb536,4
+np.float32,0xff5adb0f,0xbd441972,4
+np.float32,0xbecefe46,0xbedb0f66,4
+np.float32,0x7da70bd4,0xbec66273,4
+np.float32,0x169811,0x169811,4
+np.float32,0xbee4dfee,0xbef5721a,4
+np.float32,0x3efbeae3,0x3f0936e6,4
+np.float32,0x8031bd61,0x8031bd61,4
+np.float32,0x8048e443,0x8048e443,4
+np.float32,0xff209aa6,0xbeb364cb,4
+np.float32,0xff477499,0x3c1b0041,4
+np.float32,0x803fe929,0x803fe929,4
+np.float32,0x3f70158b,0x3fae7725,4
+np.float32,0x7f795723,0x3e8e850a,4
+np.float32,0x3cba99,0x3cba99,4
+np.float32,0x80588d2a,0x80588d2a,4
+np.float32,0x805d1f05,0x805d1f05,4
+np.float32,0xff4ac09a,0xbefe614d,4
+np.float32,0x804af084,0x804af084,4
+np.float32,0x7c64ae63,0xc1a8b563,4
+np.float32,0x8078d793,0x8078d793,4
+np.float32,0x7f3e2436,0xbf8bf9d3,4
+np.float32,0x7ccec1,0x7ccec1,4
+np.float32,0xbf6462c7,0xbf9eb830,4
+np.float32,0x3f1002ca,0x3f216843,4
+np.float32,0xfe878ca6,0x409e73a5,4
+np.float32,0x3bd841d9,0x3bd842a7,4
+np.float32,0x7d406f41,0xbd9dcfa3,4
+np.float32,0x7c6d6,0x7c6d6,4
+np.float32,0x3f4ef360,0x3f86074b,4
+np.float32,0x805f534a,0x805f534a,4
+np.float32,0x1,0x1,4
+np.float32,0x3f739ee2,0x3fb39db2,4
+np.float32,0x3d0c2352,0x3d0c3153,4
+np.float32,0xfe8a4f2c,0x3edd8add,4
+np.float32,0x3e52eaa0,0x3e55f362,4
+np.float32,0x7bde9758,0xbf5ba5cf,4
+np.float32,0xff422654,0xbf41e487,4
+np.float32,0x385e5b,0x385e5b,4
+np.float32,0x5751dd,0x5751dd,4
+np.float32,0xff6c671c,0xc03e2d6d,4
+np.float32,0x1458be,0x1458be,4
+np.float32,0x80153d4d,0x80153d4d,4
+np.float32,0x7efd2adb,0x3e25458f,4
+np.float32,0xbe161880,0xbe172e12,4
+np.float32,0x7ecea1aa,0x40a66d79,4
+np.float32,0xbf5b02a2,0xbf9355f0,4
+np.float32,0x15d9ab,0x15d9ab,4
+np.float32,0x2dc7c7,0x2dc7c7,4
+np.float32,0xfebbf81a,0x4193f6e6,4
+np.float32,0xfe8e3594,0xc00a6695,4
+np.float32,0x185aa8,0x185aa8,4
+np.float32,0x3daea156,0x3daf0e00,4
+np.float32,0x3e071688,0x3e07e08e,4
+np.float32,0x802db9e6,0x802db9e6,4
+np.float32,0x7f7be2c4,0x3f1363dd,4
+np.float32,0x7eba3f5e,0xc13eb497,4
+np.float32,0x3de04a00,0x3de130a9,4
+np.float32,0xbf1022bc,0xbf2194eb,4
+np.float32,0xbf5b547e,0xbf93b53b,4
+np.float32,0x3e867bd6,0x3e89aa10,4
+np.float32,0xbea5eb5c,0xbeabfb73,4
+np.float32,0x7f1efae9,0x3ffca038,4
+np.float32,0xff5d0344,0xbe55dbbb,4
+np.float32,0x805167e7,0x805167e7,4
+np.float32,0xbdb3a020,0xbdb41667,4
+np.float32,0xbedea6b4,0xbeedd5fd,4
+np.float32,0x8053b45c,0x8053b45c,4
+np.float32,0x7ed370e9,0x3d90eba5,4
+np.float32,0xbefcd7da,0xbf09cf91,4
+np.float32,0x78b9ac,0x78b9ac,4
+np.float32,0xbf2f6dc0,0xbf5141ef,4
+np.float32,0x802d3a7b,0x802d3a7b,4
+np.float32,0xfd45d120,0x3fec31cc,4
+np.float32,0xbf7e7020,0xbfc4b2af,4
+np.float32,0xf04da,0xf04da,4
+np.float32,0xbe9819d4,0xbe9cbd35,4
+np.float32,0x8075ab35,0x8075ab35,4
+np.float32,0xbf052fdc,0xbf12aa2c,4
+np.float32,0x3f1530d0,0x3f28bd9f,4
+np.float32,0x80791881,0x80791881,4
+np.float32,0x67f309,0x67f309,4
+np.float32,0x3f12f16a,0x3f2588f5,4
+np.float32,0x3ecdac47,0x3ed97ff8,4
+np.float32,0xbf297fb7,0xbf478c39,4
+np.float32,0x8069fa80,0x8069fa80,4
+np.float32,0x807f940e,0x807f940e,4
+np.float32,0xbf648dc8,0xbf9eeecb,4
+np.float32,0x3de873b0,0x3de9748d,4
+np.float32,0x3f1aa645,0x3f30af1f,4
+np.float32,0xff227a62,0x3d8283cc,4
+np.float32,0xbf37187d,0xbf5e5f4c,4
+np.float32,0x803b1b1f,0x803b1b1f,4
+np.float32,0x3f58142a,0x3f8ff8da,4
+np.float32,0x8004339e,0x8004339e,4
+np.float32,0xbf0f5654,0xbf2077a4,4
+np.float32,0x3f17e509,0x3f2ca598,4
+np.float32,0x3f800000,0x3fc75923,4
+np.float32,0xfdf79980,0x42f13047,4
+np.float32,0x7f111381,0x3f13c4c9,4
+np.float32,0xbea40c70,0xbea9e724,4
+np.float32,0x110520,0x110520,4
+np.float32,0x60490d,0x60490d,4
+np.float32,0x3f6703ec,0x3fa21951,4
+np.float32,0xbf098256,0xbf187652,4
+np.float32,0x658951,0x658951,4
+np.float32,0x3f53bf16,0x3f8b2818,4
+np.float32,0xff451811,0xc0026068,4
+np.float32,0x80777ee0,0x80777ee0,4
+np.float32,0x3e4fcc19,0x3e52b286,4
+np.float32,0x7f387ee0,0x3ce93eb6,4
+np.float32,0xff51181f,0xbfca3ee4,4
+np.float32,0xbf5655ae,0xbf8e0304,4
+np.float32,0xff2f1dcd,0x40025471,4
+np.float32,0x7f6e58e5,0xbe9930d5,4
+np.float32,0x7adf11,0x7adf11,4
+np.float32,0xbe9a2bc2,0xbe9f0185,4
+np.float32,0x8065d3a0,0x8065d3a0,4
+np.float32,0x3ed6e826,0x3ee47c45,4
+np.float32,0x80598ea0,0x80598ea0,4
+np.float32,0x7f10b90a,0x40437bd0,4
+np.float32,0x27b447,0x27b447,4
+np.float32,0x7ecd861c,0x3fce250f,4
+np.float32,0x0,0x0,4
+np.float32,0xbeba82d6,0xbec3394c,4
+np.float32,0xbf4958b0,0xbf8048ea,4
+np.float32,0x7c643e,0x7c643e,4
+np.float32,0x580770,0x580770,4
+np.float32,0x805bf54a,0x805bf54a,4
+np.float32,0x7f1f3cee,0xbe1a54d6,4
+np.float32,0xfefefdea,0x3fa84576,4
+np.float32,0x7f007b7a,0x3e8a6d25,4
+np.float32,0xbf177959,0xbf2c0919,4
+np.float32,0xbf30fda0,0xbf53e058,4
+np.float32,0x3f0576be,0x3f130861,4
+np.float32,0x3f49380e,0x3f80283a,4
+np.float32,0xebc56,0xebc56,4
+np.float32,0x654e3b,0x654e3b,4
+np.float32,0x14a4d8,0x14a4d8,4
+np.float32,0xff69b3cb,0xbf822a88,4
+np.float32,0xbe9b6c1c,0xbea06109,4
+np.float32,0xbefddd7e,0xbf0a787b,4
+np.float32,0x4c4ebb,0x4c4ebb,4
+np.float32,0x7d0a74,0x7d0a74,4
+np.float32,0xbebb5f80,0xbec43635,4
+np.float32,0x7ee79723,0xc1c7f3f3,4
+np.float32,0x7f2be4c7,0xbfa6c693,4
+np.float32,0x805bc7d5,0x805bc7d5,4
+np.float32,0x8042f12c,0x8042f12c,4
+np.float32,0x3ef91be8,0x3f07697b,4
+np.float32,0x3cf37ac0,0x3cf38d1c,4
+np.float32,0x800000,0x800000,4
+np.float32,0xbe1ebf4c,0xbe200806,4
+np.float32,0x7f380862,0xbeb512e8,4
+np.float32,0xbe320064,0xbe33d0fc,4
+np.float32,0xff300b0c,0xbfadb805,4
+np.float32,0x308a06,0x308a06,4
+np.float32,0xbf084f6e,0xbf16d7b6,4
+np.float32,0xff47cab6,0x3f892b65,4
+np.float32,0xbed99f4a,0xbee7bfd5,4
+np.float32,0xff7d74c0,0x3ee88c9a,4
+np.float32,0x3c3d23,0x3c3d23,4
+np.float32,0x8074bde8,0x8074bde8,4
+np.float32,0x80042164,0x80042164,4
+np.float32,0x3e97c92a,0x3e9c6500,4
+np.float32,0x3b80e0,0x3b80e0,4
+np.float32,0xbf16646a,0xbf2a783d,4
+np.float32,0x7f3b4cb1,0xc01339be,4
+np.float32,0xbf31f36e,0xbf557fd0,4
+np.float32,0x7f540618,0xbe5f6fc1,4
+np.float32,0x7eee47d0,0x40a27e94,4
+np.float32,0x7f12f389,0xbebed654,4
+np.float32,0x56cff5,0x56cff5,4
+np.float32,0x8056032b,0x8056032b,4
+np.float32,0x3ed34e40,0x3ee02e38,4
+np.float32,0x7d51a908,0xbf19a90e,4
+np.float32,0x80000000,0x80000000,4
+np.float32,0xfdf73fd0,0xbf0f8cad,4
+np.float32,0x7ee4fe6d,0xbf1ea7e4,4
+np.float32,0x1f15ba,0x1f15ba,4
+np.float32,0xd18c3,0xd18c3,4
+np.float32,0x80797705,0x80797705,4
+np.float32,0x7ef07091,0x3f2f3b9a,4
+np.float32,0x7f552f41,0x3faf608c,4
+np.float32,0x3f779977,0x3fb9a7ad,4
+np.float32,0xfe1a7a50,0xbdadc4d1,4
+np.float32,0xbf449cf0,0xbf7740db,4
+np.float32,0xbe44e620,0xbe475cad,4
+np.float32,0x3f63a098,0x3f9dc2b5,4
+np.float32,0xfed40a12,0x4164533a,4
+np.float32,0x7a2bbb,0x7a2bbb,4
+np.float32,0xff7f7b9e,0xbeee8740,4
+np.float32,0x7ee27f8b,0x4233f53b,4
+np.float32,0xbf044c06,0xbf117c28,4
+np.float32,0xbeffde54,0xbf0bc49f,4
+np.float32,0xfeaef2e8,0x3ff258fe,4
+np.float32,0x527451,0x527451,4
+np.float32,0xbcef8d00,0xbcef9e7c,4
+np.float32,0xbf0e20c0,0xbf1ec9b2,4
+np.float32,0x8024afda,0x8024afda,4
+np.float32,0x7ef6cb3e,0x422cad0b,4
+np.float32,0x3c120,0x3c120,4
+np.float32,0xbf125c8f,0xbf24b62c,4
+np.float32,0x7e770a93,0x402c9d86,4
+np.float32,0xbd30a4e0,0xbd30c0ee,4
+np.float32,0xbf4d3388,0xbf843530,4
+np.float32,0x3f529072,0x3f89df92,4
+np.float32,0xff0270b1,0xbf81be9a,4
+np.float32,0x5e07e7,0x5e07e7,4
+np.float32,0x7bec32,0x7bec32,4
+np.float32,0x7fc00000,0x7fc00000,4
+np.float32,0x3e3ba5e0,0x3e3dc6e9,4
+np.float32,0x3ecb62d4,0x3ed6ce2c,4
+np.float32,0x3eb3dde8,0x3ebba68f,4
+np.float32,0x8063f952,0x8063f952,4
+np.float32,0x7f204aeb,0x3e88614e,4
+np.float32,0xbeae1ddc,0xbeb5278e,4
+np.float32,0x6829e9,0x6829e9,4
+np.float32,0xbf361a99,0xbf5ca354,4
+np.float32,0xbf24fbe6,0xbf406326,4
+np.float32,0x3f329d41,0x3f56a061,4
+np.float32,0xfed6d666,0x3e8f71a5,4
+np.float32,0x337f92,0x337f92,4
+np.float32,0xbe1c4970,0xbe1d8305,4
+np.float32,0xbe6b7e18,0xbe6fbbde,4
+np.float32,0x3f2267b9,0x3f3c61da,4
+np.float32,0xbee1ee94,0xbef1d628,4
+np.float32,0x7ecffc1a,0x3f02987e,4
+np.float32,0xbe9b1306,0xbe9fff3b,4
+np.float32,0xbeffacae,0xbf0ba468,4
+np.float32,0x7f800000,0xffc00000,4
+np.float32,0xfefc9aa8,0xc19de2a3,4
+np.float32,0x7d7185bb,0xbf9090ec,4
+np.float32,0x7edfbafd,0x3fe9352f,4
+np.float32,0x4ef2ec,0x4ef2ec,4
+np.float32,0x7f4cab2e,0xbff4e5dd,4
+np.float32,0xff3b1788,0x3e3c22e9,4
+np.float32,0x4e15ee,0x4e15ee,4
+np.float32,0xbf5451e6,0xbf8bc8a7,4
+np.float32,0x3f7f6d2e,0x3fc65e8b,4
+np.float32,0xbf1d9184,0xbf35071b,4
+np.float32,0xbf3a81cf,0xbf646d9b,4
+np.float32,0xbe71acc4,0xbe7643ab,4
+np.float32,0x528b7d,0x528b7d,4
+np.float32,0x2cb1d0,0x2cb1d0,4
+np.float32,0x3f324bf8,0x3f56161a,4
+np.float32,0x80709a21,0x80709a21,4
+np.float32,0x4bc448,0x4bc448,4
+np.float32,0x3e8bd600,0x3e8f6b7a,4
+np.float32,0xbeb97d30,0xbec20dd6,4
+np.float32,0x2a5669,0x2a5669,4
+np.float32,0x805f2689,0x805f2689,4
+np.float32,0xfe569f50,0x3fc51952,4
+np.float32,0x1de44c,0x1de44c,4
+np.float32,0x3ec7036c,0x3ed1ae67,4
+np.float32,0x8052b8e5,0x8052b8e5,4
+np.float32,0xff740a6b,0x3f4981a8,4
+np.float32,0xfee9bb70,0xc05e23be,4
+np.float32,0xff4e12c9,0x4002b4ad,4
+np.float32,0x803de0c2,0x803de0c2,4
+np.float32,0xbf433a07,0xbf74966f,4
+np.float32,0x803e60ca,0x803e60ca,4
+np.float32,0xbf19ee98,0xbf2fa07a,4
+np.float32,0x92929,0x92929,4
+np.float32,0x7f709c27,0x4257ba2d,4
+np.float32,0x803167c6,0x803167c6,4
+np.float32,0xbf095ead,0xbf184607,4
+np.float32,0x617060,0x617060,4
+np.float32,0x2d85b3,0x2d85b3,4
+np.float32,0x53d20b,0x53d20b,4
+np.float32,0x3e046838,0x3e052666,4
+np.float32,0xbe7c5fdc,0xbe80ce4b,4
+np.float32,0x3d18d060,0x3d18e289,4
+np.float32,0x804dc031,0x804dc031,4
+np.float32,0x3f224166,0x3f3c26cd,4
+np.float32,0x7d683e3c,0xbea24f25,4
+np.float32,0xbf3a92aa,0xbf648be4,4
+np.float32,0x8072670b,0x8072670b,4
+np.float32,0xbe281aec,0xbe29a1bc,4
+np.float32,0x7f09d918,0xc0942490,4
+np.float32,0x7ca9fd07,0x4018b990,4
+np.float32,0x7d36ac5d,0x3cf57184,4
+np.float32,0x8039b62f,0x8039b62f,4
+np.float32,0x6cad7b,0x6cad7b,4
+np.float32,0x3c0fd9ab,0x3c0fda9d,4
+np.float32,0x80299883,0x80299883,4
+np.float32,0x3c2d0e3e,0x3c2d0fe4,4
+np.float32,0x8002cf62,0x8002cf62,4
+np.float32,0x801dde97,0x801dde97,4
+np.float32,0x80411856,0x80411856,4
+np.float32,0x6ebce8,0x6ebce8,4
+np.float32,0x7b7d1a,0x7b7d1a,4
+np.float32,0x8031d3de,0x8031d3de,4
+np.float32,0x8005c4ab,0x8005c4ab,4
+np.float32,0xbf7dd803,0xbfc3b3ef,4
+np.float32,0x8017ae60,0x8017ae60,4
+np.float32,0xfe9316ce,0xbfe0544a,4
+np.float32,0x3f136bfe,0x3f2636ff,4
+np.float32,0x3df87b80,0x3df9b57d,4
+np.float32,0xff44c356,0xbf11c7ad,4
+np.float32,0x4914ae,0x4914ae,4
+np.float32,0x80524c21,0x80524c21,4
+np.float32,0x805c7dc8,0x805c7dc8,4
+np.float32,0xfed3c0aa,0xbff0c0ab,4
+np.float32,0x7eb2bfbb,0xbf4600bc,4
+np.float32,0xfec8df84,0x3f5bd350,4
+np.float32,0x3e5431a4,0x3e5748c3,4
+np.float32,0xbee6a3a0,0xbef79e86,4
+np.float32,0xbf6cc9b2,0xbfa9d61a,4
+np.float32,0x3f132bd5,0x3f25dbd9,4
+np.float32,0x7e6d2e48,0x3f9d025b,4
+np.float32,0x3edf430c,0x3eee942d,4
+np.float32,0x3f0d1b8a,0x3f1d60e1,4
+np.float32,0xbdf2f688,0xbdf41bfb,4
+np.float32,0xbe47a284,0xbe4a33ff,4
+np.float32,0x3eaa9fbc,0x3eb13be7,4
+np.float32,0xfe98d45e,0x3eb84517,4
+np.float32,0x7efc23b3,0x3dcc1c99,4
+np.float32,0x3ca36242,0x3ca367ce,4
+np.float32,0x3f76a944,0x3fb834e3,4
+np.float32,0xbf45207c,0xbf783f9b,4
+np.float32,0x3e7c1220,0x3e80a4f8,4
+np.float32,0x3f018200,0x3f0dd14e,4
+np.float32,0x3f53cdde,0x3f8b3839,4
+np.float32,0xbdbacb58,0xbdbb5063,4
+np.float32,0x804af68d,0x804af68d,4
+np.float32,0x3e2c12fc,0x3e2db65b,4
+np.float32,0x3f039433,0x3f10895a,4
+np.float32,0x7ef5193d,0x3f4115f7,4
+np.float32,0x8030afbe,0x8030afbe,4
+np.float32,0x3f06fa2a,0x3f150d5d,4
+np.float32,0x3f124442,0x3f2493d2,4
+np.float32,0xbeb5b792,0xbebdc090,4
+np.float32,0xbedc90a4,0xbeeb4de9,4
+np.float32,0x3f3ff8,0x3f3ff8,4
+np.float32,0x3ee75bc5,0x3ef881e4,4
+np.float32,0xfe80e3de,0xbf5cd535,4
+np.float32,0xf52eb,0xf52eb,4
+np.float32,0x80660ee8,0x80660ee8,4
+np.float32,0x3e173a58,0x3e185648,4
+np.float32,0xfe49520c,0xbf728d7c,4
+np.float32,0xbecbb8ec,0xbed73373,4
+np.float32,0xbf027ae0,0xbf0f173e,4
+np.float32,0xbcab6740,0xbcab6da8,4
+np.float32,0xbf2a15e2,0xbf487e11,4
+np.float32,0x3b781b,0x3b781b,4
+np.float32,0x44f559,0x44f559,4
+np.float32,0xff6a0ca6,0xc174d7c3,4
+np.float32,0x6460ef,0x6460ef,4
+np.float32,0xfe58009c,0x3ee2bb30,4
+np.float32,0xfec3c038,0x3e30d617,4
+np.float32,0x7f0687c0,0xbf62c820,4
+np.float32,0xbf44655e,0xbf76d589,4
+np.float32,0xbf42968c,0xbf735e78,4
+np.float32,0x80385503,0x80385503,4
+np.float32,0xbea7e3a2,0xbeae2d59,4
+np.float32,0x3dd0b770,0x3dd17131,4
+np.float32,0xbf4bc185,0xbf82b907,4
+np.float32,0xfefd7d64,0xbee05650,4
+np.float32,0xfaac3c00,0xbff23bc9,4
+np.float32,0xbf562f0d,0xbf8dd7f4,4
+np.float32,0x7fa00000,0x7fe00000,4
+np.float32,0x3e01bdb8,0x3e027098,4
+np.float32,0x3e2868ab,0x3e29f19e,4
+np.float32,0xfec55f2e,0x3f39f304,4
+np.float32,0xed4e,0xed4e,4
+np.float32,0x3e2b7330,0x3e2d11fa,4
+np.float32,0x7f738542,0x40cbbe16,4
+np.float32,0x3f123521,0x3f247e71,4
+np.float32,0x73572c,0x73572c,4
+np.float32,0x804936c8,0x804936c8,4
+np.float32,0x803b80d8,0x803b80d8,4
+np.float32,0x7f566c57,0xbee2855a,4
+np.float32,0xff0e3bd8,0xbff0543f,4
+np.float32,0x7d2b2fe7,0xbf94ba4c,4
+np.float32,0xbf0da470,0xbf1e1dc2,4
+np.float32,0xbd276500,0xbd277ce0,4
+np.float32,0xfcd15dc0,0x403ccc2a,4
+np.float32,0x80071e59,0x80071e59,4
+np.float32,0xbe9b0c34,0xbe9ff7be,4
+np.float32,0x3f4f9069,0x3f86ac50,4
+np.float32,0x80042a95,0x80042a95,4
+np.float32,0x7de28e39,0x3bc9b7f4,4
+np.float32,0xbf641935,0xbf9e5af8,4
+np.float32,0x8034f068,0x8034f068,4
+np.float32,0xff33a3d2,0xbf408e75,4
+np.float32,0xbcc51540,0xbcc51efc,4
+np.float32,0xff6d1ddf,0x3ef58f0e,4
+np.float32,0xbf64dfc4,0xbf9f5725,4
+np.float32,0xff068a06,0x3eea8987,4
+np.float32,0xff01c0af,0x3f24cdfe,4
+np.float32,0x3f4def7e,0x3f84f802,4
+np.float32,0xbf1b4ae7,0xbf31a299,4
+np.float32,0x8077df2d,0x8077df2d,4
+np.float32,0x3f0155c5,0x3f0d9785,4
+np.float32,0x5a54b2,0x5a54b2,4
+np.float32,0x7f271f9e,0x3efb2ef3,4
+np.float32,0xbf0ff2ec,0xbf215217,4
+np.float32,0x7f500130,0xbf8a7fdd,4
+np.float32,0xfed9891c,0xbf65c872,4
+np.float32,0xfecbfaae,0x403bdbc2,4
+np.float32,0x3f3a5aba,0x3f642772,4
+np.float32,0x7ebc681e,0xbd8df059,4
+np.float32,0xfe05e400,0xbfe35d74,4
+np.float32,0xbf295ace,0xbf4750ea,4
+np.float32,0x7ea055b2,0x3f62d6be,4
+np.float32,0xbd00b520,0xbd00bff9,4
+np.float32,0xbf7677aa,0xbfb7e8cf,4
+np.float32,0x3e83f788,0x3e86f816,4
+np.float32,0x801f6710,0x801f6710,4
+np.float32,0x801133cc,0x801133cc,4
+np.float32,0x41da2a,0x41da2a,4
+np.float32,0xff1622fd,0x3f023650,4
+np.float32,0x806c7a72,0x806c7a72,4
+np.float32,0x3f10779c,0x3f220bb4,4
+np.float32,0xbf08cf94,0xbf17848d,4
+np.float32,0xbecb55b4,0xbed6bebd,4
+np.float32,0xbf0a1528,0xbf193d7b,4
+np.float32,0x806a16bd,0x806a16bd,4
+np.float32,0xc222a,0xc222a,4
+np.float32,0x3930de,0x3930de,4
+np.float32,0x3f5c3588,0x3f94bca2,4
+np.float32,0x1215ad,0x1215ad,4
+np.float32,0x3ed15030,0x3eddcf67,4
+np.float32,0x7da83b2e,0x3fce0d39,4
+np.float32,0x32b0a8,0x32b0a8,4
+np.float32,0x805aed6b,0x805aed6b,4
+np.float32,0x3ef8e02f,0x3f074346,4
+np.float32,0xbdeb6780,0xbdec7250,4
+np.float32,0x3f6e3cec,0x3fabda61,4
+np.float32,0xfefd467a,0x3ef7821a,4
+np.float32,0xfef090fe,0x3bb752a2,4
+np.float32,0x8019c538,0x8019c538,4
+np.float32,0x3e8cf284,0x3e909e81,4
+np.float32,0xbe6c6618,0xbe70b0a2,4
+np.float32,0x7f50a539,0x3f367be1,4
+np.float32,0x8019fe2f,0x8019fe2f,4
+np.float32,0x800c3f48,0x800c3f48,4
+np.float32,0xfd054cc0,0xc0f52802,4
+np.float32,0x3d0cca20,0x3d0cd853,4
+np.float32,0xbf4a7c44,0xbf816e74,4
+np.float32,0x3f46fc40,0x3f7be153,4
+np.float32,0x807c5849,0x807c5849,4
+np.float32,0xd7e41,0xd7e41,4
+np.float32,0x70589b,0x70589b,4
+np.float32,0x80357b95,0x80357b95,4
+np.float32,0x3de239f0,0x3de326a5,4
+np.float32,0x800b08e3,0x800b08e3,4
+np.float32,0x807ec946,0x807ec946,4
+np.float32,0x3e2e4b83,0x3e2fff76,4
+np.float32,0x3f198e0f,0x3f2f12a6,4
+np.float32,0xbecb1aca,0xbed67979,4
+np.float32,0x80134082,0x80134082,4
+np.float32,0x3f3a269f,0x3f63ca05,4
+np.float32,0x3f1381e4,0x3f265622,4
+np.float32,0xff293080,0xbf10be6f,4
+np.float32,0xff800000,0xffc00000,4
+np.float32,0x37d196,0x37d196,4
+np.float32,0x7e57eea7,0x3e7d8138,4
+np.float32,0x804b1dae,0x804b1dae,4
+np.float32,0x7d9508f9,0xc1075b35,4
+np.float32,0x3f7bf468,0x3fc095e0,4
+np.float32,0x55472c,0x55472c,4
+np.float32,0x3ecdcd86,0x3ed9a738,4
+np.float32,0x3ed9be0f,0x3ee7e4e9,4
+np.float32,0x3e7e0ddb,0x3e81b2fe,4
+np.float32,0x7ee6c1d3,0x3f850634,4
+np.float32,0x800f6fad,0x800f6fad,4
+np.float32,0xfefb3bd6,0xbff68ecc,4
+np.float32,0x8013d6e2,0x8013d6e2,4
+np.float32,0x3f3a2cb6,0x3f63d4ee,4
+np.float32,0xff383c84,0x3e7854bb,4
+np.float32,0x3f21946e,0x3f3b1cea,4
+np.float32,0xff322ea2,0x3fb22f31,4
+np.float32,0x8065a024,0x8065a024,4
+np.float32,0x7f395e30,0xbefe0de1,4
+np.float32,0x5b52db,0x5b52db,4
+np.float32,0x7f7caea7,0x3dac8ded,4
+np.float32,0xbf0431f8,0xbf1159b2,4
+np.float32,0x7f15b25b,0xc02a3833,4
+np.float32,0x80131abc,0x80131abc,4
+np.float32,0x7e829d81,0xbeb2e93d,4
+np.float32,0x3f2c64d7,0x3f4c3e4d,4
+np.float32,0x7f228d48,0xc1518c74,4
+np.float32,0xfc3c6f40,0xbf00d585,4
+np.float32,0x7f754f0f,0x3e2152f5,4
+np.float32,0xff65d32b,0xbe8bd56c,4
+np.float32,0xfea6b8c0,0x41608655,4
+np.float32,0x3f7d4b05,0x3fc2c96a,4
+np.float32,0x3f463230,0x3f7a54da,4
+np.float32,0x805117bb,0x805117bb,4
+np.float32,0xbf2ad4f7,0xbf49b30e,4
+np.float32,0x3eaa01ff,0x3eb08b56,4
+np.float32,0xff7a02bb,0x3f095f73,4
+np.float32,0x759176,0x759176,4
+np.float32,0x803c18d5,0x803c18d5,4
+np.float32,0xbe0722d8,0xbe07ed16,4
+np.float32,0x3f4b4a99,0x3f823fc6,4
+np.float32,0x3f7d0451,0x3fc25463,4
+np.float32,0xfee31e40,0xbfb41091,4
+np.float32,0xbf733d2c,0xbfb30cf1,4
+np.float32,0x7ed81015,0x417c380c,4
+np.float32,0x7daafc3e,0xbe2a37ed,4
+np.float32,0x3e44f82b,0x3e476f67,4
+np.float32,0x7c8d99,0x7c8d99,4
+np.float32,0x3f7aec5a,0x3fbee991,4
+np.float32,0xff09fd55,0x3e0709d3,4
+np.float32,0xff4ba4df,0x4173c01f,4
+np.float32,0x3f43d944,0x3f75c7bd,4
+np.float32,0xff6a9106,0x40a10eff,4
+np.float32,0x3bc8341c,0x3bc834bf,4
+np.float32,0x3eea82,0x3eea82,4
+np.float32,0xfea36a3c,0x435729b2,4
+np.float32,0x7dcc1fb0,0x3e330053,4
+np.float32,0x3f616ae6,0x3f9b01ae,4
+np.float32,0x8030963f,0x8030963f,4
+np.float32,0x10d1e2,0x10d1e2,4
+np.float32,0xfeb9a8a6,0x40e6daac,4
+np.float32,0xbe1aba00,0xbe1bea3a,4
+np.float32,0x3cb6b4ea,0x3cb6bcac,4
+np.float32,0x3d8b0b64,0x3d8b422f,4
+np.float32,0x7b6894,0x7b6894,4
+np.float32,0x3e89dcde,0x3e8d4b4b,4
+np.float32,0x3f12b952,0x3f253974,4
+np.float32,0x1c316c,0x1c316c,4
+np.float32,0x7e2da535,0x3f95fe6b,4
+np.float32,0x3ae9a494,0x3ae9a4a4,4
+np.float32,0xbc5f5500,0xbc5f588b,4
+np.float32,0x3e7850fc,0x3e7d4d0e,4
+np.float32,0xbf800000,0xbfc75923,4
+np.float32,0x3e652d69,0x3e691502,4
+np.float32,0xbf6bdd26,0xbfa89129,4
+np.float32,0x3f441cfc,0x3f764a02,4
+np.float32,0x7f5445ff,0xc0906191,4
+np.float32,0x807b2ee3,0x807b2ee3,4
+np.float32,0xbeb6cab8,0xbebef9c0,4
+np.float32,0xff737277,0xbf327011,4
+np.float32,0xfc832aa0,0x402fd52e,4
+np.float32,0xbf0c7538,0xbf1c7c0f,4
+np.float32,0x7e1301c7,0xbf0ee63e,4
+np.float64,0xbfe0ef7df7a1defc,0xbfe2b76a8d8aeb35,4
+np.float64,0x7fdd9c2eae3b385c,0xbfc00d6885485039,4
+np.float64,0xbfb484c710290990,0xbfb4900e0a527555,4
+np.float64,0x7fe73e5d6cee7cba,0x3fefbf70a56b60d3,4
+np.float64,0x800a110aa8d42216,0x800a110aa8d42216,4
+np.float64,0xffedd4f3f3bba9e7,0xbff076f8c4124919,4
+np.float64,0x800093407f812682,0x800093407f812682,4
+np.float64,0x800a23150e54462a,0x800a23150e54462a,4
+np.float64,0xbfb1076864220ed0,0xbfb10dd95a74b733,4
+np.float64,0x3fed1f8b37fa3f16,0x3ff496100985211f,4
+np.float64,0x3fdf762f84beec5f,0x3fe1223eb04a17e0,4
+np.float64,0x53fd4e0aa7faa,0x53fd4e0aa7faa,4
+np.float64,0x3fdbd283bdb7a507,0x3fddb7ec9856a546,4
+np.float64,0xbfe43f449d687e89,0xbfe77724a0d3072b,4
+np.float64,0x618b73bcc316f,0x618b73bcc316f,4
+np.float64,0x67759424ceeb3,0x67759424ceeb3,4
+np.float64,0xbfe4b6f7d9a96df0,0xbfe831371f3bd7a8,4
+np.float64,0x800a531b8b74a637,0x800a531b8b74a637,4
+np.float64,0xffeeffd5c37dffab,0x3fea140cbc2c3726,4
+np.float64,0x3fe648e2002c91c4,0x3feac1b8816f972a,4
+np.float64,0x800f16242a1e2c48,0x800f16242a1e2c48,4
+np.float64,0xffeeff8e1dbdff1b,0xc000b555f117dce7,4
+np.float64,0x3fdf1cf73fbe39f0,0x3fe0e9032401135b,4
+np.float64,0x7fe19c388b633870,0x3fd5271b69317d5b,4
+np.float64,0x918f226d231e5,0x918f226d231e5,4
+np.float64,0x4cc19ab499834,0x4cc19ab499834,4
+np.float64,0xbd3121d57a624,0xbd3121d57a624,4
+np.float64,0xbfd145d334a28ba6,0xbfd1b468866124d6,4
+np.float64,0x8bdbf41517b7f,0x8bdbf41517b7f,4
+np.float64,0x3fd1b8cb3ea37198,0x3fd2306b13396cae,4
+np.float64,0xbfd632a959ac6552,0xbfd7220fcfb5ef78,4
+np.float64,0x1cdaafc639b57,0x1cdaafc639b57,4
+np.float64,0x3febdcce1577b99c,0x3ff2fe076195a2bc,4
+np.float64,0x7fca6e945934dd28,0x3ff43040df7024e8,4
+np.float64,0x3fbe08e78e3c11cf,0x3fbe2c60e6b48f75,4
+np.float64,0x7fc1ed0d0523da19,0x3ff55f8dcad9440f,4
+np.float64,0xbfdc729b8cb8e538,0xbfde7b6e15dd60c4,4
+np.float64,0x3fd219404f243281,0x3fd298d7b3546531,4
+np.float64,0x3fe715c3f56e2b88,0x3fec255b5a59456e,4
+np.float64,0x7fe8b88e74b1711c,0x3ff60efd2c81d13d,4
+np.float64,0xa1d2b9fd43a57,0xa1d2b9fd43a57,4
+np.float64,0xffc1818223230304,0xbfb85c6c1e8018e7,4
+np.float64,0x3fde38ac8b3c7159,0x3fe0580c7e228576,4
+np.float64,0x8008faf7b491f5f0,0x8008faf7b491f5f0,4
+np.float64,0xffe7a1d751af43ae,0xbf7114cd7bbcd981,4
+np.float64,0xffec2db1b4b85b62,0xbff5cae759667f83,4
+np.float64,0x7fefce1ae27f9c35,0x3ff4b8b88f4876cf,4
+np.float64,0x7fd1ff56a523feac,0xbff342ce192f14dd,4
+np.float64,0x80026b3e3f84d67d,0x80026b3e3f84d67d,4
+np.float64,0xffedee5879bbdcb0,0xc02fae11508b2be0,4
+np.float64,0x8003c0dc822781ba,0x8003c0dc822781ba,4
+np.float64,0xffe38a79eca714f4,0xc008aa23b7a63980,4
+np.float64,0xbfda70411eb4e082,0xbfdc0d7e29c89010,4
+np.float64,0x800a5e34f574bc6a,0x800a5e34f574bc6a,4
+np.float64,0x3fc19fac6e233f59,0x3fc1bc66ac0d73d4,4
+np.float64,0x3a8a61ea7514d,0x3a8a61ea7514d,4
+np.float64,0x3fb57b536e2af6a0,0x3fb588451f72f44c,4
+np.float64,0x7fd68c6d082d18d9,0xc032ac926b665c9a,4
+np.float64,0xd5b87cfdab710,0xd5b87cfdab710,4
+np.float64,0xfe80b20bfd017,0xfe80b20bfd017,4
+np.float64,0x3fef8781e37f0f04,0x3ff8215fe2c1315a,4
+np.float64,0xffedddbb9c3bbb76,0x3fd959b82258a32a,4
+np.float64,0x3fc7d41f382fa83e,0x3fc81b94c3a091ba,4
+np.float64,0xffc3275dcf264ebc,0x3fb2b3d4985c6078,4
+np.float64,0x7fe34d2b7ba69a56,0x40001f3618e3c7c9,4
+np.float64,0x3fd64ae35fac95c7,0x3fd73d77e0b730f8,4
+np.float64,0x800e53bf6b3ca77f,0x800e53bf6b3ca77f,4
+np.float64,0xbfddf7c9083bef92,0xbfe02f392744d2d1,4
+np.float64,0x1c237cc038471,0x1c237cc038471,4
+np.float64,0x3fe4172beea82e58,0x3fe739b4bf16bc7e,4
+np.float64,0xfa950523f52a1,0xfa950523f52a1,4
+np.float64,0xffc839a2c5307344,0xbff70ff8a3c9247f,4
+np.float64,0x264f828c4c9f1,0x264f828c4c9f1,4
+np.float64,0x148a650a2914e,0x148a650a2914e,4
+np.float64,0x3fe8d255c0b1a4ac,0x3fef623c3ea8d6e3,4
+np.float64,0x800f4fbb28be9f76,0x800f4fbb28be9f76,4
+np.float64,0x7fdca57bcfb94af7,0x3ff51207563fb6cb,4
+np.float64,0x3fe4944107692882,0x3fe7fad593235364,4
+np.float64,0x800119b4f1a2336b,0x800119b4f1a2336b,4
+np.float64,0xbfe734075e6e680e,0xbfec5b35381069f2,4
+np.float64,0xffeb3c00db767801,0xbfbbd7d22df7b4b3,4
+np.float64,0xbfe95c658cb2b8cb,0xbff03ad5e0bc888a,4
+np.float64,0xffeefeb58fbdfd6a,0xbfd5c9264deb0e11,4
+np.float64,0x7fccc80fde39901f,0xc012c60f914f3ca2,4
+np.float64,0x3fe5da289c2bb451,0x3fea07ad00a0ca63,4
+np.float64,0x800e364b0a5c6c96,0x800e364b0a5c6c96,4
+np.float64,0x3fcf9ea7d23f3d50,0x3fd023b72e8c9dcf,4
+np.float64,0x800a475cfc948eba,0x800a475cfc948eba,4
+np.float64,0xffd4e0d757a9c1ae,0xbfa89d573352e011,4
+np.float64,0xbfd4dbec8229b7da,0xbfd5a165f12c7c40,4
+np.float64,0xffe307ab51260f56,0x3fe6b1639da58c3f,4
+np.float64,0xbfe6955a546d2ab4,0xbfeb44ae2183fee9,4
+np.float64,0xbfca1f18f5343e30,0xbfca7d804ccccdf4,4
+np.float64,0xe9f4dfebd3e9c,0xe9f4dfebd3e9c,4
+np.float64,0xfff0000000000000,0xfff8000000000000,4
+np.float64,0x8008e69c0fb1cd38,0x8008e69c0fb1cd38,4
+np.float64,0xbfead1ccf975a39a,0xbff1c84b3db8ca93,4
+np.float64,0x25a982424b531,0x25a982424b531,4
+np.float64,0x8010000000000000,0x8010000000000000,4
+np.float64,0x80056204ea0ac40b,0x80056204ea0ac40b,4
+np.float64,0x800d1442d07a2886,0x800d1442d07a2886,4
+np.float64,0xbfaef3dadc3de7b0,0xbfaefd85ae6205f0,4
+np.float64,0x7fe969ce4b32d39c,0xbff3c4364fc6778f,4
+np.float64,0x7fe418bac0a83175,0x402167d16b1efe0b,4
+np.float64,0x3fd7c82a25af9054,0x3fd8f0c701315672,4
+np.float64,0x80013782a7826f06,0x80013782a7826f06,4
+np.float64,0x7fc031c7ee20638f,0x400747ab705e6904,4
+np.float64,0x3fe8cf327ff19e65,0x3fef5c14f8aafa89,4
+np.float64,0xbfe331a416a66348,0xbfe5e2290a098dd4,4
+np.float64,0x800607b2116c0f65,0x800607b2116c0f65,4
+np.float64,0x7fb40448f0280891,0xbfd43d4f0ffa1d64,4
+np.float64,0x7fefffffffffffff,0xbf74530cfe729484,4
+np.float64,0x3fe39b5444a736a9,0x3fe67eaa0b6acf27,4
+np.float64,0x3fee4733c4fc8e68,0x3ff631eabeef9696,4
+np.float64,0xbfec840f3b79081e,0xbff3cc8563ab2e74,4
+np.float64,0xbfc8f6854c31ed0c,0xbfc948caacb3bba0,4
+np.float64,0xffbcf754a639eea8,0xbfc88d17cad3992b,4
+np.float64,0x8000bd3163417a64,0x8000bd3163417a64,4
+np.float64,0x3fe766d0eaeecda2,0x3fecb660882f7024,4
+np.float64,0xb6cc30156d986,0xb6cc30156d986,4
+np.float64,0xffc0161f9f202c40,0x3fe19bdefe5cf8b1,4
+np.float64,0xffe1e462caa3c8c5,0x3fe392c47feea17b,4
+np.float64,0x30a36a566146e,0x30a36a566146e,4
+np.float64,0x3fa996f580332deb,0x3fa99c6b4f2abebe,4
+np.float64,0x3fba71716e34e2e0,0x3fba899f35edba1d,4
+np.float64,0xbfe8f7e5e971efcc,0xbfefac431a0e3d55,4
+np.float64,0xf48f1803e91e3,0xf48f1803e91e3,4
+np.float64,0x7fe3edc0a127db80,0xc03d1a579a5d74a8,4
+np.float64,0xffeba82056375040,0x3fdfd701308700db,4
+np.float64,0xbfeb5a924cf6b524,0xbff2640de7cd107f,4
+np.float64,0xfa4cd1a9f499a,0xfa4cd1a9f499a,4
+np.float64,0x800de1be7b9bc37d,0x800de1be7b9bc37d,4
+np.float64,0xffd44e56ad289cae,0x3fdf4b8085db9b67,4
+np.float64,0xbfe4fb3aea69f676,0xbfe89d2cc46fcc50,4
+np.float64,0xbfe596495d6b2c92,0xbfe997a589a1f632,4
+np.float64,0x6f55a2b8deab5,0x6f55a2b8deab5,4
+np.float64,0x7fe72dc4712e5b88,0x4039c4586b28c2bc,4
+np.float64,0x89348bd712692,0x89348bd712692,4
+np.float64,0xffe062156120c42a,0x4005f0580973bc77,4
+np.float64,0xbfeabc714d7578e2,0xbff1b07e2fa57dc0,4
+np.float64,0x8003a56b3e874ad7,0x8003a56b3e874ad7,4
+np.float64,0x800eeadfb85dd5c0,0x800eeadfb85dd5c0,4
+np.float64,0x46d77a4c8daf0,0x46d77a4c8daf0,4
+np.float64,0x8000c06e7dc180de,0x8000c06e7dc180de,4
+np.float64,0x3fe428d211e851a4,0x3fe754b1c00a89bc,4
+np.float64,0xc5be11818b7c2,0xc5be11818b7c2,4
+np.float64,0x7fefc244893f8488,0x401133dc54f52de5,4
+np.float64,0x3fde30eee93c61de,0x3fe0532b827543a6,4
+np.float64,0xbfd447f48b288fea,0xbfd4fd0654f90718,4
+np.float64,0xbfde98dc7b3d31b8,0xbfe094df12f84a06,4
+np.float64,0x3fed2c1a1dfa5834,0x3ff4a6c4f3470a65,4
+np.float64,0xbfe992165073242d,0xbff071ab039c9177,4
+np.float64,0x3fd0145d1b2028ba,0x3fd06d3867b703dc,4
+np.float64,0x3fe179457362f28b,0x3fe3722f1d045fda,4
+np.float64,0x800e28964fbc512d,0x800e28964fbc512d,4
+np.float64,0x8004a5d785294bb0,0x8004a5d785294bb0,4
+np.float64,0xbfd652f2272ca5e4,0xbfd7469713125120,4
+np.float64,0x7fe61f49036c3e91,0xbf9b6ccdf2d87e70,4
+np.float64,0xffb7d47dd02fa8f8,0xc004449a82320b13,4
+np.float64,0x3feb82f996b705f3,0x3ff29336c738a4c5,4
+np.float64,0x3fbb7fceea36ffa0,0x3fbb9b02c8ad7f93,4
+np.float64,0x80004519fb208a35,0x80004519fb208a35,4
+np.float64,0xbfe0539114e0a722,0xbfe1e86dc5aa039c,4
+np.float64,0x0,0x0,4
+np.float64,0xbfe99d1125f33a22,0xbff07cf8ec04300f,4
+np.float64,0xffd4fbeecc29f7de,0x3ffab76775a8455f,4
+np.float64,0xbfbf1c618e3e38c0,0xbfbf43d2764a8333,4
+np.float64,0x800cae02a9d95c06,0x800cae02a9d95c06,4
+np.float64,0x3febc47d3bf788fa,0x3ff2e0d7cf8ef509,4
+np.float64,0x3fef838f767f071f,0x3ff81aeac309bca0,4
+np.float64,0xbfd5e70716abce0e,0xbfd6ccb033ef7a35,4
+np.float64,0x3f9116fa60222df5,0x3f9117625f008e0b,4
+np.float64,0xffe02b1e5f20563c,0xbfe6b2ec293520b7,4
+np.float64,0xbf9b5aec3036b5e0,0xbf9b5c96c4c7f951,4
+np.float64,0xfdb0169bfb603,0xfdb0169bfb603,4
+np.float64,0x7fcdd1d51c3ba3a9,0x401f0e12fa0b7570,4
+np.float64,0xbfd088103fa11020,0xbfd0e8c4a333ffb2,4
+np.float64,0x3fe22df82ee45bf0,0x3fe46d03a7c14de2,4
+np.float64,0xbfd57b0c28aaf618,0xbfd65349a6191de5,4
+np.float64,0x3fe0a42f50a1485f,0x3fe252e26775d9a4,4
+np.float64,0x800fab4e363f569c,0x800fab4e363f569c,4
+np.float64,0xffe9f0ed63f3e1da,0xbfe278c341b171d5,4
+np.float64,0x7fe26c244664d848,0xbfb325269dad1996,4
+np.float64,0xffe830410bf06081,0xc00181a39f606e96,4
+np.float64,0x800c548a0c78a914,0x800c548a0c78a914,4
+np.float64,0x800f94761ebf28ec,0x800f94761ebf28ec,4
+np.float64,0x3fe5984845eb3091,0x3fe99aeb653c666d,4
+np.float64,0x7fe93e5bf8f27cb7,0xc010d159fa27396a,4
+np.float64,0xffefffffffffffff,0x3f74530cfe729484,4
+np.float64,0x4c83f1269907f,0x4c83f1269907f,4
+np.float64,0x3fde0065a8bc00cc,0x3fe034a1cdf026d4,4
+np.float64,0x800743810d6e8703,0x800743810d6e8703,4
+np.float64,0x80040662d5280cc6,0x80040662d5280cc6,4
+np.float64,0x3fed20b2c5ba4166,0x3ff497988519d7aa,4
+np.float64,0xffe8fa15e5f1f42b,0x3fff82ca76d797b4,4
+np.float64,0xbb72e22f76e5d,0xbb72e22f76e5d,4
+np.float64,0x7fc18ffa7c231ff4,0xbff4b8b4c3315026,4
+np.float64,0xbfe8d1ac44f1a358,0xbfef60efc4f821e3,4
+np.float64,0x3fd38c1fe8271840,0x3fd42dc37ff7262b,4
+np.float64,0xe577bee5caef8,0xe577bee5caef8,4
+np.float64,0xbff0000000000000,0xbff8eb245cbee3a6,4
+np.float64,0xffcb3a9dd436753c,0x3fcd1a3aff1c3fc7,4
+np.float64,0x7fe44bf2172897e3,0x3ff60bfe82a379f4,4
+np.float64,0x8009203823924071,0x8009203823924071,4
+np.float64,0x7fef8e0abc7f1c14,0x3fe90e4962d47ce5,4
+np.float64,0xffda50004434a000,0x3fb50dee03e1418b,4
+np.float64,0x7fe2ff276ea5fe4e,0xc0355b7d2a0a8d9d,4
+np.float64,0x3fd0711ba5a0e238,0x3fd0d03823d2d259,4
+np.float64,0xe7625b03cec4c,0xe7625b03cec4c,4
+np.float64,0xbfd492c8d7a92592,0xbfd55006cde8d300,4
+np.float64,0x8001fee99f23fdd4,0x8001fee99f23fdd4,4
+np.float64,0x7ff4000000000000,0x7ffc000000000000,4
+np.float64,0xfa15df97f42bc,0xfa15df97f42bc,4
+np.float64,0xbfec3fdca9787fb9,0xbff377164b13c7a9,4
+np.float64,0xbcec10e579d82,0xbcec10e579d82,4
+np.float64,0xbfc3b4e2132769c4,0xbfc3dd1fcc7150a6,4
+np.float64,0x80045b149ee8b62a,0x80045b149ee8b62a,4
+np.float64,0xffe044554c2088aa,0xbff741436d558785,4
+np.float64,0xffcc65f09f38cbe0,0xc0172b4adc2d317d,4
+np.float64,0xf68b2d3bed166,0xf68b2d3bed166,4
+np.float64,0x7fc7f44c572fe898,0x3fec69f3b1eca790,4
+np.float64,0x3fac51f61438a3ec,0x3fac595d34156002,4
+np.float64,0xbfeaa9f256f553e5,0xbff19bfdf5984326,4
+np.float64,0x800e4742149c8e84,0x800e4742149c8e84,4
+np.float64,0xbfc493df132927c0,0xbfc4c1ba4268ead9,4
+np.float64,0xbfbf0c56383e18b0,0xbfbf3389fcf50c72,4
+np.float64,0xbf978a0e082f1420,0xbf978b1dd1da3d3c,4
+np.float64,0xbfe04375356086ea,0xbfe1d34c57314dd1,4
+np.float64,0x3feaeeb29b75dd65,0x3ff1e8b772374979,4
+np.float64,0xbfe15e42c3a2bc86,0xbfe34d45d56c5c15,4
+np.float64,0x3fe507429a6a0e85,0x3fe8b058176b3225,4
+np.float64,0x3feee2b26c3dc565,0x3ff71b73203de921,4
+np.float64,0xbfd496577aa92cae,0xbfd553fa7fe15a5f,4
+np.float64,0x7fe2c10953e58212,0x3fc8ead6a0d14bbf,4
+np.float64,0x800035b77aa06b70,0x800035b77aa06b70,4
+np.float64,0x2329201e46525,0x2329201e46525,4
+np.float64,0xbfe6225c9a6c44b9,0xbfea80861590fa02,4
+np.float64,0xbfd6925030ad24a0,0xbfd78e70b1c2215d,4
+np.float64,0xbfd82225c4b0444c,0xbfd958a60f845b39,4
+np.float64,0xbb03d8a17609,0xbb03d8a17609,4
+np.float64,0x7fc33967b12672ce,0x40001e00c9af4002,4
+np.float64,0xff9373c6d026e780,0xbff308654a459d3d,4
+np.float64,0x3feab1f9c5f563f4,0x3ff1a4e0fd2f093d,4
+np.float64,0xbf993ef768327de0,0xbf994046b64e308b,4
+np.float64,0xffb87382fc30e708,0xbfde0accb83c891b,4
+np.float64,0x800bb3a118176743,0x800bb3a118176743,4
+np.float64,0x800c810250d90205,0x800c810250d90205,4
+np.float64,0xbfd2c4eb9ba589d8,0xbfd3539508b4a4a8,4
+np.float64,0xbee1f5437dc3f,0xbee1f5437dc3f,4
+np.float64,0x3fc07aeab520f5d8,0x3fc0926272f9d8e2,4
+np.float64,0xbfe23747a3246e90,0xbfe47a20a6e98687,4
+np.float64,0x3fde1296debc252c,0x3fe0401143ff6b5c,4
+np.float64,0xbfcec8c2f73d9184,0xbfcf644e25ed3b74,4
+np.float64,0xff9314f2c82629e0,0x40559a0f9099dfd1,4
+np.float64,0xbfe27487afa4e910,0xbfe4d0e01200bde6,4
+np.float64,0xffb3d6637627acc8,0x3fe326d4b1e1834f,4
+np.float64,0xffe6f84d642df09a,0x3fc73fa9f57c3acb,4
+np.float64,0xffe67cf76fecf9ee,0xc01cf48c97937ef9,4
+np.float64,0x7fdc73fc12b8e7f7,0xbfcfcecde9331104,4
+np.float64,0xffdcf8789239f0f2,0x3fe345e3b8e28776,4
+np.float64,0x800a70af5314e15f,0x800a70af5314e15f,4
+np.float64,0xffc862300730c460,0x3fc4e9ea813beca7,4
+np.float64,0xbfcc6961bd38d2c4,0xbfcce33bfa6c6bd1,4
+np.float64,0xbfc9b76bbf336ed8,0xbfca117456ac37e5,4
+np.float64,0x7fb86e829430dd04,0x400a5bd7a18e302d,4
+np.float64,0x7fb9813ef833027d,0xbfe5a6494f143625,4
+np.float64,0x8005085e2c2a10bd,0x8005085e2c2a10bd,4
+np.float64,0xffe5af099d6b5e12,0x40369bbe31e03e06,4
+np.float64,0xffde03b1fd3c0764,0x3ff061120aa1f52a,4
+np.float64,0x7fa4eb6cdc29d6d9,0x3fe9defbe9010322,4
+np.float64,0x800803f4b11007ea,0x800803f4b11007ea,4
+np.float64,0x7febd50f6df7aa1e,0xbffcf540ccf220dd,4
+np.float64,0x7fed454f08fa8a9d,0xbffc2a8b81079403,4
+np.float64,0xbfed7e8c69bafd19,0xbff5161e51ba6634,4
+np.float64,0xffef92e78eff25ce,0xbffefeecddae0ad3,4
+np.float64,0x7fe5b9b413ab7367,0xbfc681ba29704176,4
+np.float64,0x29284e805252,0x29284e805252,4
+np.float64,0xffed3955bcfa72ab,0xbfc695acb5f468de,4
+np.float64,0x3fe464ee1ca8c9dc,0x3fe7b140ce50fdca,4
+np.float64,0xffe522ae4bea455c,0x3feb957c146e66ef,4
+np.float64,0x8000000000000000,0x8000000000000000,4
+np.float64,0x3fd0c353a2a186a8,0x3fd1283aaa43a411,4
+np.float64,0x3fdb30a749b6614f,0x3fdcf40df006ed10,4
+np.float64,0x800109213cc21243,0x800109213cc21243,4
+np.float64,0xbfe72aa0c5ee5542,0xbfec4a713f513bc5,4
+np.float64,0x800865344ad0ca69,0x800865344ad0ca69,4
+np.float64,0x7feb7df60eb6fbeb,0x3fb1df06a67aa22f,4
+np.float64,0x3fe83a5dd93074bc,0x3fee3d63cda72636,4
+np.float64,0xbfde70e548bce1ca,0xbfe07b8e19c9dac6,4
+np.float64,0xbfeea38d537d471b,0xbff6bb18c230c0be,4
+np.float64,0x3fefeebbc47fdd78,0x3ff8cdaa53b7c7b4,4
+np.float64,0x7fe6512e20eca25b,0xbff623cee44a22b5,4
+np.float64,0xf8fa5ca3f1f4c,0xf8fa5ca3f1f4c,4
+np.float64,0x7fd12d00ed225a01,0xbfe90d518ea61faf,4
+np.float64,0x80027db43504fb69,0x80027db43504fb69,4
+np.float64,0xffc10a01aa221404,0x3fcc2065b3d0157b,4
+np.float64,0xbfef8286e87f050e,0xbff8193a54449b59,4
+np.float64,0xbfc73178092e62f0,0xbfc7735072ba4593,4
+np.float64,0x3fc859d70630b3ae,0x3fc8a626522af1c0,4
+np.float64,0x3fe4654c4268ca99,0x3fe7b1d2913eda1a,4
+np.float64,0xbfce93cd843d279c,0xbfcf2c2ef16a0957,4
+np.float64,0xffbcaa16d4395430,0xbfd511ced032d784,4
+np.float64,0xbfe91f980e723f30,0xbfeffb39cf8c7746,4
+np.float64,0x800556fb6f0aadf8,0x800556fb6f0aadf8,4
+np.float64,0xffd009cde520139c,0x3fe4fa83b1e93d28,4
+np.float64,0x7febc0675e3780ce,0x3feb53930c004dae,4
+np.float64,0xbfe7f975bdeff2ec,0xbfedc36e6729b010,4
+np.float64,0x45aff57c8b5ff,0x45aff57c8b5ff,4
+np.float64,0xbfec7ebd0138fd7a,0xbff3c5cab680aae0,4
+np.float64,0x8009448003b28900,0x8009448003b28900,4
+np.float64,0x3fca4b992d349732,0x3fcaabebcc86aa9c,4
+np.float64,0x3fca069161340d20,0x3fca63ecc742ff3a,4
+np.float64,0x80063bc80bec7791,0x80063bc80bec7791,4
+np.float64,0xbfe1764bffe2ec98,0xbfe36e1cb30cec94,4
+np.float64,0xffd0dba72f21b74e,0x3fb1834964d57ef6,4
+np.float64,0xbfe31848fc263092,0xbfe5bd066445cbc3,4
+np.float64,0xbfd1fb227323f644,0xbfd278334e27f02d,4
+np.float64,0xffdc59069fb8b20e,0xbfdfc363f559ea2c,4
+np.float64,0x3fdea52a52bd4a55,0x3fe09cada4e5344c,4
+np.float64,0x3f715e55a022bd00,0x3f715e5c72a2809e,4
+np.float64,0x1d1ac6023a35a,0x1d1ac6023a35a,4
+np.float64,0x7feacc71627598e2,0x400486b82121da19,4
+np.float64,0xa0287fa340510,0xa0287fa340510,4
+np.float64,0xffe352c5abe6a58b,0xc002623346060543,4
+np.float64,0x7fed577a23baaef3,0x3fda19bc8fa3b21f,4
+np.float64,0x3fde8dd5263d1baa,0x3fe08de0fedf7029,4
+np.float64,0x3feddd3be2bbba78,0x3ff599b2f3e018cc,4
+np.float64,0xc7a009f58f401,0xc7a009f58f401,4
+np.float64,0xbfef03d5a4fe07ab,0xbff74ee08681f47b,4
+np.float64,0x7fe2cf60eea59ec1,0x3fe905fb44f8cc60,4
+np.float64,0xbfe498fcab6931fa,0xbfe8023a6ff8becf,4
+np.float64,0xbfef7142acfee285,0xbff7fd196133a595,4
+np.float64,0xd214ffdba42a0,0xd214ffdba42a0,4
+np.float64,0x8006de7d78cdbcfc,0x8006de7d78cdbcfc,4
+np.float64,0xb247d34f648fb,0xb247d34f648fb,4
+np.float64,0xbfdd5bece6bab7da,0xbfdf9ba63ca2c5b2,4
+np.float64,0x7fe874650af0e8c9,0x3fe74204e122c10f,4
+np.float64,0x800768c49baed18a,0x800768c49baed18a,4
+np.float64,0x3fb4c0a192298140,0x3fb4cc4c8aa43300,4
+np.float64,0xbfa740531c2e80a0,0xbfa7446b7c74ae8e,4
+np.float64,0x7fe10d6edf221add,0x3fedbcd2eae26657,4
+np.float64,0xbfe9175d0f722eba,0xbfefeaca7f32c6e3,4
+np.float64,0x953e11d32a7c2,0x953e11d32a7c2,4
+np.float64,0x80032df90c465bf3,0x80032df90c465bf3,4
+np.float64,0xffec5b799638b6f2,0xbfe95cd2c69be12c,4
+np.float64,0xffe0c3cfa9a1879f,0x3fe20b99b0c108ce,4
+np.float64,0x3fb610d8e22c21b2,0x3fb61ee0d6c16df8,4
+np.float64,0xffe16bb39962d766,0xc016d370381b6b42,4
+np.float64,0xbfdc72edb238e5dc,0xbfde7bd2de10717a,4
+np.float64,0xffed52dee3baa5bd,0xc01994c08899129a,4
+np.float64,0xffa92aab08325550,0xbff2b881ce363cbd,4
+np.float64,0x7fe028282de0504f,0xc0157ff96c69a9c7,4
+np.float64,0xbfdb2151bf3642a4,0xbfdce196fcc35857,4
+np.float64,0x3fcffbd13c3ff7a2,0x3fd0554b5f0371ac,4
+np.float64,0x800d206bff1a40d8,0x800d206bff1a40d8,4
+np.float64,0x458f818c8b1f1,0x458f818c8b1f1,4
+np.float64,0x800a7b56a234f6ae,0x800a7b56a234f6ae,4
+np.float64,0xffe3d86161e7b0c2,0xbff58d0dbde9f188,4
+np.float64,0xe8ed82e3d1db1,0xe8ed82e3d1db1,4
+np.float64,0x3fe234e0176469c0,0x3fe476bd36b96a75,4
+np.float64,0xbfc7cb9c132f9738,0xbfc812c46e185e0b,4
+np.float64,0xbfeba116c1f7422e,0xbff2b6b7563ad854,4
+np.float64,0x7fe7041de62e083b,0x3f5d2b42aca47274,4
+np.float64,0xbfcf60f4ff3ec1e8,0xbfd002eb83406436,4
+np.float64,0xbfc06067a520c0d0,0xbfc0776e5839ecda,4
+np.float64,0x4384965a87093,0x4384965a87093,4
+np.float64,0xd2ed9d01a5db4,0xd2ed9d01a5db4,4
+np.float64,0x3fbea88cb63d5119,0x3fbece49cc34a379,4
+np.float64,0x3fe7e982ebefd306,0x3feda5bd4c435d43,4
+np.float64,0xffdb60a3e036c148,0xbfcb7ed21e7a8f49,4
+np.float64,0x7fdba9231eb75245,0xbfd750cab1536398,4
+np.float64,0x800d593534dab26b,0x800d593534dab26b,4
+np.float64,0xffdf15fb683e2bf6,0x3fb3aaea23357f06,4
+np.float64,0xbfd6f8a2e5adf146,0xbfd802e509d67c67,4
+np.float64,0x3feeaa31513d5463,0x3ff6c52147dc053c,4
+np.float64,0xf2f6dfd3e5edc,0xf2f6dfd3e5edc,4
+np.float64,0x7fd58d8279ab1b04,0x403243f23d02af2a,4
+np.float64,0x8000000000000001,0x8000000000000001,4
+np.float64,0x3fdffb8e0ebff71c,0x3fe1786cb0a6b0f3,4
+np.float64,0xc999826b93331,0xc999826b93331,4
+np.float64,0xffc4966f19292ce0,0x3ff0836c75c56cc7,4
+np.float64,0x7fef95a4b2ff2b48,0xbfbbe2c27c78154f,4
+np.float64,0xb8f1307f71e26,0xb8f1307f71e26,4
+np.float64,0x3fe807bc7eb00f79,0x3fedde19f2d3c42d,4
+np.float64,0x5e4b6580bc98,0x5e4b6580bc98,4
+np.float64,0xffe19353576326a6,0xc0278c51fee07d36,4
+np.float64,0xbfb0ca6f3e2194e0,0xbfb0d09be673fa72,4
+np.float64,0x3fea724211b4e484,0x3ff15ee06f0a0a13,4
+np.float64,0xbfda21e1c4b443c4,0xbfdbb041f3c86832,4
+np.float64,0x8008082b24901057,0x8008082b24901057,4
+np.float64,0xbfd031aa4ea06354,0xbfd08c77729634bb,4
+np.float64,0xbfc407e153280fc4,0xbfc432275711df5f,4
+np.float64,0xbb4fa4b5769f5,0xbb4fa4b5769f5,4
+np.float64,0x7fed6d1daffada3a,0xc037a14bc7b41fab,4
+np.float64,0xffeee589943dcb12,0x3ff2abfe47037778,4
+np.float64,0x301379d260270,0x301379d260270,4
+np.float64,0xbfec2fefc2b85fe0,0xbff36362c0363e06,4
+np.float64,0xbfe0b1c82e216390,0xbfe264f503f7c22c,4
+np.float64,0xbfea2bce78f4579d,0xbff112d6f07935ea,4
+np.float64,0x18508ef230a13,0x18508ef230a13,4
+np.float64,0x800667a74d6ccf4f,0x800667a74d6ccf4f,4
+np.float64,0x79ce5c8cf39cc,0x79ce5c8cf39cc,4
+np.float64,0x3feda61c8efb4c39,0x3ff54c9ade076f54,4
+np.float64,0x3fe27e06b0e4fc0d,0x3fe4de665c1dc3ca,4
+np.float64,0xbfd15fea2722bfd4,0xbfd1d081c55813b0,4
+np.float64,0xbfe5222c4cea4458,0xbfe8db62deb7d2ad,4
+np.float64,0xbfe8a16c33b142d8,0xbfef02d5831592a8,4
+np.float64,0x3fdb60e7c4b6c1d0,0x3fdd2e4265c4c3b6,4
+np.float64,0x800076d62b60edad,0x800076d62b60edad,4
+np.float64,0xbfec8f1527791e2a,0xbff3da7ed3641e8d,4
+np.float64,0x2af03bfe55e08,0x2af03bfe55e08,4
+np.float64,0xa862ee0950c5e,0xa862ee0950c5e,4
+np.float64,0x7fea5a7c1eb4b4f7,0xbffa6f07d28ef211,4
+np.float64,0x90e118fb21c23,0x90e118fb21c23,4
+np.float64,0xbfead0721bf5a0e4,0xbff1c6c7a771a128,4
+np.float64,0x3f63f4a4c027e94a,0x3f63f4a75665da67,4
+np.float64,0x3fece0efa579c1e0,0x3ff443bec52f021e,4
+np.float64,0xbfdbe743b737ce88,0xbfddd129bff89c15,4
+np.float64,0x3fd48c9b8fa91938,0x3fd5492a630a8cb5,4
+np.float64,0x3ff0000000000000,0x3ff8eb245cbee3a6,4
+np.float64,0xbfd51ea33baa3d46,0xbfd5ebd5dc710204,4
+np.float64,0x3fcfbab0183f7560,0x3fd032a054580b00,4
+np.float64,0x8007abce13cf579d,0x8007abce13cf579d,4
+np.float64,0xbfef0f4723be1e8e,0xbff760c7008e8913,4
+np.float64,0x8006340f524c681f,0x8006340f524c681f,4
+np.float64,0x87b7d7010f71,0x87b7d7010f71,4
+np.float64,0x3fe9422da9b2845b,0x3ff02052e6148c45,4
+np.float64,0x7fddd259b93ba4b2,0xc000731aa33d84b6,4
+np.float64,0x3fe0156d12202ada,0x3fe1972ba309cb29,4
+np.float64,0x8004f1264b89e24d,0x8004f1264b89e24d,4
+np.float64,0x3fececdcacb9d9b9,0x3ff4534d5861f731,4
+np.float64,0x3fd1790ab822f215,0x3fd1eb97b1bb6fb4,4
+np.float64,0xffce5d11863cba24,0xbfcb4f38c17210da,4
+np.float64,0x800a30c32a546187,0x800a30c32a546187,4
+np.float64,0x3fa58cc61c2b198c,0x3fa59008add7233e,4
+np.float64,0xbfe0ac77d62158f0,0xbfe25de3dba0bc4a,4
+np.float64,0xeb8c5753d718b,0xeb8c5753d718b,4
+np.float64,0x3fee5438dafca872,0x3ff644fef7e7adb5,4
+np.float64,0x3faad1eb2c35a3e0,0x3faad83499f94057,4
+np.float64,0x3fe39152c46722a6,0x3fe66fba0b96ab6e,4
+np.float64,0xffd6fd17712dfa2e,0xc010d697d1ab8731,4
+np.float64,0x5214a888a4296,0x5214a888a4296,4
+np.float64,0x8000127a5da024f5,0x8000127a5da024f5,4
+np.float64,0x7feb3a366cb6746c,0x3fbe49bd8d5f213a,4
+np.float64,0xca479501948f3,0xca479501948f3,4
+np.float64,0x7fe7c799ce6f8f33,0xbfd796cd98dc620c,4
+np.float64,0xffe20bcf30a4179e,0xbff8ca5453fa088f,4
+np.float64,0x3fe624638a6c48c7,0x3fea83f123832c3c,4
+np.float64,0xbfe5f1377c6be26f,0xbfea2e143a2d522c,4
+np.float64,0x7fd193f9f8a327f3,0xbfb04ee2602574d4,4
+np.float64,0xbfe7419d2fee833a,0xbfec737f140d363d,4
+np.float64,0x1,0x1,4
+np.float64,0x7fe2ac246c655848,0x3fd14fee3237727a,4
+np.float64,0xa459b42948b37,0xa459b42948b37,4
+np.float64,0x3fb26155ae24c2ab,0x3fb2696fc446d4c6,4
+np.float64,0xbfdd7b332e3af666,0xbfdfc296c21f1aa8,4
+np.float64,0xbfe00dbda4a01b7c,0xbfe18d2b060f0506,4
+np.float64,0x8003bb22d3e77646,0x8003bb22d3e77646,4
+np.float64,0x3fee21b0a57c4361,0x3ff5fb6a21dc911c,4
+np.float64,0x80ca69270194d,0x80ca69270194d,4
+np.float64,0xbfd6d80350adb006,0xbfd7ddb501edbde0,4
+np.float64,0xd2f8b801a5f2,0xd2f8b801a5f2,4
+np.float64,0xbfe856b3f170ad68,0xbfee7334fdc49296,4
+np.float64,0x3fed5c1b20bab836,0x3ff4e73ee5d5c7f3,4
+np.float64,0xbfd58085a5ab010c,0xbfd6596ddc381ffa,4
+np.float64,0x3fe4f0134b29e027,0x3fe88b70602fbd21,4
+np.float64,0xffc9098fdc321320,0x4011c334a74a92cf,4
+np.float64,0x794749bef28ea,0x794749bef28ea,4
+np.float64,0xbfc86b547f30d6a8,0xbfc8b84a4fafe0af,4
+np.float64,0x7fe1356b9da26ad6,0x3fd270bca208d899,4
+np.float64,0x7fca0ef1aa341de2,0xbff851044c0734fa,4
+np.float64,0x80064cb8b62c9972,0x80064cb8b62c9972,4
+np.float64,0xffd3a09a83a74136,0x3ffb66dae0accdf5,4
+np.float64,0x800e301aa15c6035,0x800e301aa15c6035,4
+np.float64,0x800e51f323bca3e6,0x800e51f323bca3e6,4
+np.float64,0x7ff0000000000000,0xfff8000000000000,4
+np.float64,0x800c4278c87884f2,0x800c4278c87884f2,4
+np.float64,0xbfe8481649f0902c,0xbfee576772695096,4
+np.float64,0xffe2344e3fa4689c,0x3fb10442ec0888de,4
+np.float64,0xbfeada313d75b462,0xbff1d1aee3fab3a9,4
+np.float64,0x8009ddfb1333bbf7,0x8009ddfb1333bbf7,4
+np.float64,0x7fed3314c93a6629,0x3ff7a9b12dc1cd37,4
+np.float64,0x3fd55c26da2ab84e,0x3fd630a7b8aac78a,4
+np.float64,0x800cdb5203f9b6a4,0x800cdb5203f9b6a4,4
+np.float64,0xffd04a875da0950e,0x4009a13810ab121d,4
+np.float64,0x800f1acb527e3597,0x800f1acb527e3597,4
+np.float64,0xbf9519bf282a3380,0xbf951a82e9b955ff,4
+np.float64,0x3fcd7a42fa3af486,0x3fce028f3c51072d,4
+np.float64,0xbfdd3e21b73a7c44,0xbfdf769f2ff2480b,4
+np.float64,0xffd4361e2aa86c3c,0xbfc211ce8e9f792c,4
+np.float64,0x7fccf97f6939f2fe,0xbff8464bad830f06,4
+np.float64,0x800ce47fb939c900,0x800ce47fb939c900,4
+np.float64,0xffe9e51df173ca3b,0xbfceaf990d652c4e,4
+np.float64,0x3fe05bba5b20b775,0x3fe1f326e4455442,4
+np.float64,0x800a29b4b134536a,0x800a29b4b134536a,4
+np.float64,0xe6f794b7cdef3,0xe6f794b7cdef3,4
+np.float64,0xffb5b688ce2b6d10,0x3ff924bb97ae2f6d,4
+np.float64,0x7fa74105d82e820b,0x3fd49643aaa9eee4,4
+np.float64,0x80020d15f7a41a2d,0x80020d15f7a41a2d,4
+np.float64,0x3fd6a983d5ad5308,0x3fd7a8cc8835b5b8,4
+np.float64,0x7fcd9798f03b2f31,0x3fc534c2f7bf4721,4
+np.float64,0xffdd31873a3a630e,0xbfe3171fcdffb3f7,4
+np.float64,0x80075183234ea307,0x80075183234ea307,4
+np.float64,0x82f3132505e63,0x82f3132505e63,4
+np.float64,0x3febfd9cb837fb39,0x3ff325bbf812515d,4
+np.float64,0xbfb4630fda28c620,0xbfb46e1f802ec278,4
+np.float64,0x3feeed7c89fddafa,0x3ff72c20ce5a9ee4,4
+np.float64,0x7fd3dcb3c127b967,0x40123d27ec9ec31d,4
+np.float64,0xbfe923450c72468a,0xbff00149c5742725,4
+np.float64,0x7fdef7f91abdeff1,0xbfe02ceb21f7923d,4
+np.float64,0x7fdd70d28fbae1a4,0xbfefcc5c9d10cdfd,4
+np.float64,0x800ca445a8d9488c,0x800ca445a8d9488c,4
+np.float64,0x7fec2754e1f84ea9,0x40173f6c1c97f825,4
+np.float64,0x7fcbca31f7379463,0x401e26bd2667075b,4
+np.float64,0x8003fa1d0847f43b,0x8003fa1d0847f43b,4
+np.float64,0xffe95cf85932b9f0,0xc01308e60278aa11,4
+np.float64,0x8009c53948f38a73,0x8009c53948f38a73,4
+np.float64,0x3fdcca9226b99524,0x3fdee7a008f75d41,4
+np.float64,0xbfe9ee241f33dc48,0xbff0d16bfff6c8e9,4
+np.float64,0xbfb3365058266ca0,0xbfb33f9176ebb51d,4
+np.float64,0x7fa98e10f4331c21,0x3fdee04ffd31314e,4
+np.float64,0xbfe1a11aea634236,0xbfe3a8e3d84fda38,4
+np.float64,0xbfd8df051131be0a,0xbfda342805d1948b,4
+np.float64,0x3d49a2407a935,0x3d49a2407a935,4
+np.float64,0xfc51eefff8a3e,0xfc51eefff8a3e,4
+np.float64,0xda63950bb4c73,0xda63950bb4c73,4
+np.float64,0x80050f3d4fea1e7b,0x80050f3d4fea1e7b,4
+np.float64,0x3fcdbd6e453b7ae0,0x3fce497478c28e77,4
+np.float64,0x7ebd4932fd7aa,0x7ebd4932fd7aa,4
+np.float64,0x7fa3904eac27209c,0xc0015f3125efc151,4
+np.float64,0x7fc59f956b2b3f2a,0xc00c012e7a2c281f,4
+np.float64,0xbfd436d716a86dae,0xbfd4ea13533a942b,4
+np.float64,0x9347ae3d268f6,0x9347ae3d268f6,4
+np.float64,0xffd001764d2002ec,0xbffab3462e515623,4
+np.float64,0x3fe6f406662de80d,0x3febe9bac3954999,4
+np.float64,0x3f943ecaf8287d96,0x3f943f77dee5e77f,4
+np.float64,0x3fd6250efcac4a1c,0x3fd712afa947d56f,4
+np.float64,0xbfe849ff777093ff,0xbfee5b089d03391f,4
+np.float64,0xffd3b8ef8f2771e0,0x4000463ff7f29214,4
+np.float64,0xbfc3bae9252775d4,0xbfc3e34c133f1933,4
+np.float64,0xbfea93943df52728,0xbff18355e4fc341d,4
+np.float64,0x3fc4d922ad29b245,0x3fc508d66869ef29,4
+np.float64,0x4329694a8652e,0x4329694a8652e,4
+np.float64,0x8834f1a71069e,0x8834f1a71069e,4
+np.float64,0xe0e5be8dc1cb8,0xe0e5be8dc1cb8,4
+np.float64,0x7fef4d103afe9a1f,0xc0047b88b94554fe,4
+np.float64,0x3fe9b57af4f36af6,0x3ff0963831d51c3f,4
+np.float64,0x3fe081e2fa6103c6,0x3fe22572e41be655,4
+np.float64,0x3fd78cf7b42f19ef,0x3fd8acafa1ad776a,4
+np.float64,0x7fbffd58d43ffab1,0x3fb16092c7de6036,4
+np.float64,0xbfe1e8bfae23d180,0xbfe40c1c6277dd52,4
+np.float64,0x800a9f59fb153eb4,0x800a9f59fb153eb4,4
+np.float64,0xffebe14e33b7c29c,0x3fe0ec532f4deedd,4
+np.float64,0xffc36ca00426d940,0xc000806a712d6e83,4
+np.float64,0xbfcc2be82d3857d0,0xbfcca2a7d372ec64,4
+np.float64,0x800c03b908780772,0x800c03b908780772,4
+np.float64,0xf315a64be62b5,0xf315a64be62b5,4
+np.float64,0xbfe644043cec8808,0xbfeab974d3dc6d80,4
+np.float64,0x3fedb7de3cbb6fbc,0x3ff56549a5acd324,4
+np.float64,0xbfb1a875522350e8,0xbfb1afa41dee338d,4
+np.float64,0xffee8d4a407d1a94,0x3fead1749a636ff6,4
+np.float64,0x8004061c13080c39,0x8004061c13080c39,4
+np.float64,0x3fe650ae7feca15c,0x3feacefb8bc25f64,4
+np.float64,0x3fda8340e6b50682,0x3fdc24275cab1df8,4
+np.float64,0x8009084344321087,0x8009084344321087,4
+np.float64,0x7fdd19cb823a3396,0xbfd1d8fb35d89e3f,4
+np.float64,0xbfe893172571262e,0xbfeee716b592b93c,4
+np.float64,0x8ff5acc11fec,0x8ff5acc11fec,4
+np.float64,0xbfdca0c57cb9418a,0xbfdeb42465a1b59e,4
+np.float64,0xffd77bd2a3aef7a6,0x4012cd69e85b82d8,4
+np.float64,0xbfe6ea78982dd4f1,0xbfebd8ec61fb9e1f,4
+np.float64,0x7fe14b1d80a2963a,0xc02241642102cf71,4
+np.float64,0x3fe712bf286e257e,0x3fec20012329a7fb,4
+np.float64,0x7fcb6fa4d636df49,0x400b899d14a886b3,4
+np.float64,0x3fb82cb39a305960,0x3fb83f29c5f0822e,4
+np.float64,0x7fed694c8b3ad298,0xbfe2724373c69808,4
+np.float64,0xbfcd21229f3a4244,0xbfcda497fc3e1245,4
+np.float64,0x564d3770ac9a8,0x564d3770ac9a8,4
+np.float64,0xf4409e13e8814,0xf4409e13e8814,4
+np.float64,0x80068dca9a8d1b96,0x80068dca9a8d1b96,4
+np.float64,0xbfe13f82afe27f06,0xbfe3236ddded353f,4
+np.float64,0x80023f8114647f03,0x80023f8114647f03,4
+np.float64,0xeafba7dfd5f75,0xeafba7dfd5f75,4
+np.float64,0x3feca74ddeb94e9c,0x3ff3f95dcce5a227,4
+np.float64,0x10000000000000,0x10000000000000,4
+np.float64,0xbfebdb4141f7b682,0xbff2fc29823ac64a,4
+np.float64,0xbfcd75ee2f3aebdc,0xbfcdfdfd87cc6a29,4
+np.float64,0x7fc010cda420219a,0x3fae4ca2cf1f2657,4
+np.float64,0x1a90209e35205,0x1a90209e35205,4
+np.float64,0x8008057d01900afa,0x8008057d01900afa,4
+np.float64,0x3f9cb5f280396be5,0x3f9cb7dfb4e4be4e,4
+np.float64,0xffe1bbb60b63776c,0xc00011b1ffcb2561,4
+np.float64,0xffda883f6fb5107e,0x4044238ef4e2a198,4
+np.float64,0x3fc07c0b4a20f817,0x3fc09387de9eebcf,4
+np.float64,0x8003a9ebc0c753d8,0x8003a9ebc0c753d8,4
+np.float64,0x1d7fd5923affc,0x1d7fd5923affc,4
+np.float64,0xbfe9cd8cf9b39b1a,0xbff0af43e567ba4a,4
+np.float64,0x11285cb42250c,0x11285cb42250c,4
+np.float64,0xffe81ae1ccb035c3,0xbfe038be7eb563a6,4
+np.float64,0xbfe56473b1eac8e8,0xbfe94654d8ab9e75,4
+np.float64,0x3fee904619fd208c,0x3ff69e198152fe17,4
+np.float64,0xbfeeb9a2cbfd7346,0xbff6dc8d96da78cd,4
+np.float64,0x8006cdfa59ed9bf5,0x8006cdfa59ed9bf5,4
+np.float64,0x8008f2366d31e46d,0x8008f2366d31e46d,4
+np.float64,0x8008d5f91e31abf3,0x8008d5f91e31abf3,4
+np.float64,0x3fe85886f8b0b10e,0x3fee76af16f5a126,4
+np.float64,0x3fefb9b2b73f7365,0x3ff8745128fa3e3b,4
+np.float64,0x7fdf3e721f3e7ce3,0xbfb19381541ca2a8,4
+np.float64,0x3fd2768c41a4ed18,0x3fd2fe2f85a3f3a6,4
+np.float64,0xbfcabe3c6a357c78,0xbfcb239fb88bc260,4
+np.float64,0xffdffb6a3dbff6d4,0xbff7af4759fd557c,4
+np.float64,0x800817f75f302fef,0x800817f75f302fef,4
+np.float64,0xbfe6a1d1762d43a3,0xbfeb5a399a095ef3,4
+np.float64,0x7fd6f32f912de65e,0x40016dedc51aabd0,4
+np.float64,0x3fc6cb26652d964d,0x3fc7099f047d924a,4
+np.float64,0x3fe8b975d67172ec,0x3fef31946123c0e7,4
+np.float64,0xffe44a09d1e89413,0x3fdee9e5eac6e540,4
+np.float64,0xbfece76d4cb9cedb,0xbff44c34849d07ba,4
+np.float64,0x7feb76027036ec04,0x3fe08595a5e263ac,4
+np.float64,0xffe194f591a329ea,0x3fbe5bd626400a70,4
+np.float64,0xbfc170698122e0d4,0xbfc18c3de8b63565,4
+np.float64,0x3fc82b2c0f305658,0x3fc875c3b5fbcd08,4
+np.float64,0x3fd5015634aa02ac,0x3fd5cb1df07213c3,4
+np.float64,0x7fe640884b6c8110,0xbff66255a420abb5,4
+np.float64,0x5a245206b448b,0x5a245206b448b,4
+np.float64,0xffe9d9fa2f73b3f4,0xc0272b0dd34ab9bf,4
+np.float64,0x3fd990e8aab321d0,0x3fdb04cd3a29bcc3,4
+np.float64,0xde9dda8bbd3bc,0xde9dda8bbd3bc,4
+np.float64,0xbfe81b32b4703666,0xbfee029937fa9f5a,4
+np.float64,0xbfe68116886d022d,0xbfeb21c62081cb73,4
+np.float64,0x3fb8da191231b432,0x3fb8ee28c71507d3,4
+np.float64,0x3fb111395a222273,0x3fb117b57de3dea4,4
+np.float64,0xffbafadc6a35f5b8,0x3ffcc6d2370297b9,4
+np.float64,0x8002ca475b05948f,0x8002ca475b05948f,4
+np.float64,0xbfeafef57875fdeb,0xbff1fb1315676f24,4
+np.float64,0x7fcda427d73b484f,0xbff9f70212694d17,4
+np.float64,0xffe2517b3ba4a2f6,0xc029ca6707305bf4,4
+np.float64,0x7fc5ee156b2bdc2a,0xbff8384b59e9056e,4
+np.float64,0xbfec22af3278455e,0xbff3530fe25816b4,4
+np.float64,0x6b5a8c2cd6b52,0x6b5a8c2cd6b52,4
+np.float64,0xffdaf6c4b935ed8a,0x4002f00ce58affcf,4
+np.float64,0x800a41813c748303,0x800a41813c748303,4
+np.float64,0xbfd09a1269213424,0xbfd0fc0a0c5de8eb,4
+np.float64,0x7fa2cb74d42596e9,0x3fc3d40e000fa69d,4
+np.float64,0x7ff8000000000000,0x7ff8000000000000,4
+np.float64,0x3fbfbf8ed63f7f1e,0x3fbfe97bcad9f53a,4
+np.float64,0x7fe0ebba65a1d774,0x401b0f17b28618df,4
+np.float64,0x3fd02c3a25a05874,0x3fd086aa55b19c9c,4
+np.float64,0xec628f95d8c52,0xec628f95d8c52,4
+np.float64,0x3fd319329fa63264,0x3fd3afb04e0dec63,4
+np.float64,0x180e0ade301c2,0x180e0ade301c2,4
+np.float64,0xbfe8d78324f1af06,0xbfef6c66153064ee,4
+np.float64,0xffb89fa200313f48,0xbfeb96ff2d9358dc,4
+np.float64,0x7fe6abcf86ed579e,0xc0269f4de86365ec,4
+np.float64,0x7fdff8cd65bff19a,0xbfd0f7c6b9052c9a,4
+np.float64,0xbfd2e3a53d25c74a,0xbfd37520cda5f6b2,4
+np.float64,0x7fe844b096708960,0x3ff696a6182e5a7a,4
+np.float64,0x7fdce0c7a3b9c18e,0x3fd42875d69ed379,4
+np.float64,0xffba5a91cc34b520,0x4001b571e8991951,4
+np.float64,0xffe78fe4a6ef1fc9,0x3ff4507b31f5b3bc,4
+np.float64,0xbfd7047493ae08ea,0xbfd810618a53fffb,4
+np.float64,0xc6559def8cab4,0xc6559def8cab4,4
+np.float64,0x3fe75d67a76ebacf,0x3feca56817de65e4,4
+np.float64,0xffd24adbd6a495b8,0xc012c491addf2df5,4
+np.float64,0x7fed35e28dba6bc4,0x403a0fa555ff7ec6,4
+np.float64,0x80078c4afa0f1897,0x80078c4afa0f1897,4
+np.float64,0xa6ec39114dd87,0xa6ec39114dd87,4
+np.float64,0x7fb1bd33ba237a66,0x4010092bb6810fd4,4
+np.float64,0x800ecf215edd9e43,0x800ecf215edd9e43,4
+np.float64,0x3fb7c169242f82d2,0x3fb7d2ed30c462e6,4
+np.float64,0xbf71b46d60236900,0xbf71b4749a10c112,4
+np.float64,0x800d7851787af0a3,0x800d7851787af0a3,4
+np.float64,0x3fcb4a45e7369488,0x3fcbb61701a1bcec,4
+np.float64,0x3fd4e3682429c6d0,0x3fd5a9bcb916eb94,4
+np.float64,0x800497564c292ead,0x800497564c292ead,4
+np.float64,0xbfca3737a1346e70,0xbfca96a86ae5d687,4
+np.float64,0x19aa87e03356,0x19aa87e03356,4
+np.float64,0xffb2593fe624b280,0xc05fedb99b467ced,4
+np.float64,0xbfdd8748fbbb0e92,0xbfdfd1a7df17252c,4
+np.float64,0x8004c7afc7098f60,0x8004c7afc7098f60,4
+np.float64,0x7fde48b2bf3c9164,0xbfe36ef1158ed420,4
+np.float64,0xbfec8e0eb0f91c1d,0xbff3d9319705a602,4
+np.float64,0xffea1be204f437c3,0xc0144f67298c3e6f,4
+np.float64,0x7fdb906b593720d6,0xbfce99233396eda7,4
+np.float64,0x3fef0f114ffe1e22,0x3ff76072a258a51b,4
+np.float64,0x3fe3e284c8e7c50a,0x3fe6e9b05e17c999,4
+np.float64,0xbfbda9eef23b53e0,0xbfbdcc1abb443597,4
+np.float64,0x3feb6454d4f6c8aa,0x3ff26f65a85baba4,4
+np.float64,0x3fea317439f462e8,0x3ff118e2187ef33f,4
+np.float64,0x376ad0646ed5b,0x376ad0646ed5b,4
+np.float64,0x7fdd461a1c3a8c33,0x3f7ba20fb79e785f,4
+np.float64,0xebc520a3d78a4,0xebc520a3d78a4,4
+np.float64,0x3fca90fe53352200,0x3fcaf45c7fae234d,4
+np.float64,0xbfe80dd1de701ba4,0xbfede97e12cde9de,4
+np.float64,0x3fd242b00ea48560,0x3fd2c5cf9bf69a31,4
+np.float64,0x7fe46c057828d80a,0xbfe2f76837488f94,4
+np.float64,0x3fc162bea322c580,0x3fc17e517c958867,4
+np.float64,0xffebf0452ff7e08a,0x3ffc3fd95c257b54,4
+np.float64,0xffd88043c6310088,0x4008b05598d0d95f,4
+np.float64,0x800d8c49da5b1894,0x800d8c49da5b1894,4
+np.float64,0xbfed33b487ba6769,0xbff4b0ea941f8a6a,4
+np.float64,0x16b881e22d711,0x16b881e22d711,4
+np.float64,0x288bae0051177,0x288bae0051177,4
+np.float64,0xffc83a0fe8307420,0x4006eff03da17f86,4
+np.float64,0x3fc7868b252f0d18,0x3fc7cb4954290324,4
+np.float64,0xbfe195514b232aa2,0xbfe398aae6c8ed76,4
+np.float64,0x800c001ae7f80036,0x800c001ae7f80036,4
+np.float64,0x7feb82abe7370557,0xbff1e13fe6fad23c,4
+np.float64,0xffecf609cdf9ec13,0xc0112aa1805ae59e,4
+np.float64,0xffddd654f63bacaa,0x3fe46cce899f710d,4
+np.float64,0x3fe2163138642c62,0x3fe44b9c760acd4c,4
+np.float64,0x4e570dc09cae2,0x4e570dc09cae2,4
+np.float64,0x7fe9e8d091f3d1a0,0xc000fe20f8e9a4b5,4
+np.float64,0x7fe60042952c0084,0x3fd0aa740f394c2a,4

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/test_arrayprint.py

@@ -0,0 +1,1047 @@
+import sys
+import gc
+from hypothesis import given
+from hypothesis.extra import numpy as hynp
+import pytest
+
+import numpy as np
+from numpy.testing import (
+    assert_, assert_equal, assert_raises, assert_warns, HAS_REFCOUNT,
+    assert_raises_regex,
+    )
+from numpy.core.arrayprint import _typelessdata
+import textwrap
+
+class TestArrayRepr:
+    def test_nan_inf(self):
+        x = np.array([np.nan, np.inf])
+        assert_equal(repr(x), 'array([nan, inf])')
+
+    def test_subclass(self):
+        class sub(np.ndarray): pass
+
+        # one dimensional
+        x1d = np.array([1, 2]).view(sub)
+        assert_equal(repr(x1d), 'sub([1, 2])')
+
+        # two dimensional
+        x2d = np.array([[1, 2], [3, 4]]).view(sub)
+        assert_equal(repr(x2d),
+            'sub([[1, 2],\n'
+            '     [3, 4]])')
+
+        # two dimensional with flexible dtype
+        xstruct = np.ones((2,2), dtype=[('a', '<i4')]).view(sub)
+        assert_equal(repr(xstruct),
+            "sub([[(1,), (1,)],\n"
+            "     [(1,), (1,)]], dtype=[('a', '<i4')])"
+        )
+
+    @pytest.mark.xfail(reason="See gh-10544")
+    def test_object_subclass(self):
+        class sub(np.ndarray):
+            def __new__(cls, inp):
+                obj = np.asarray(inp).view(cls)
+                return obj
+
+            def __getitem__(self, ind):
+                ret = super().__getitem__(ind)
+                return sub(ret)
+
+        # test that object + subclass is OK:
+        x = sub([None, None])
+        assert_equal(repr(x), 'sub([None, None], dtype=object)')
+        assert_equal(str(x), '[None None]')
+
+        x = sub([None, sub([None, None])])
+        assert_equal(repr(x),
+            'sub([None, sub([None, None], dtype=object)], dtype=object)')
+        assert_equal(str(x), '[None sub([None, None], dtype=object)]')
+
+    def test_0d_object_subclass(self):
+        # make sure that subclasses which return 0ds instead
+        # of scalars don't cause infinite recursion in str
+        class sub(np.ndarray):
+            def __new__(cls, inp):
+                obj = np.asarray(inp).view(cls)
+                return obj
+
+            def __getitem__(self, ind):
+                ret = super().__getitem__(ind)
+                return sub(ret)
+
+        x = sub(1)
+        assert_equal(repr(x), 'sub(1)')
+        assert_equal(str(x), '1')
+
+        x = sub([1, 1])
+        assert_equal(repr(x), 'sub([1, 1])')
+        assert_equal(str(x), '[1 1]')
+
+        # check it works properly with object arrays too
+        x = sub(None)
+        assert_equal(repr(x), 'sub(None, dtype=object)')
+        assert_equal(str(x), 'None')
+
+        # plus recursive object arrays (even depth > 1)
+        y = sub(None)
+        x[()] = y
+        y[()] = x
+        assert_equal(repr(x),
+            'sub(sub(sub(..., dtype=object), dtype=object), dtype=object)')
+        assert_equal(str(x), '...')
+        x[()] = 0  # resolve circular references for garbage collector
+
+        # nested 0d-subclass-object
+        x = sub(None)
+        x[()] = sub(None)
+        assert_equal(repr(x), 'sub(sub(None, dtype=object), dtype=object)')
+        assert_equal(str(x), 'None')
+
+        # gh-10663
+        class DuckCounter(np.ndarray):
+            def __getitem__(self, item):
+                result = super().__getitem__(item)
+                if not isinstance(result, DuckCounter):
+                    result = result[...].view(DuckCounter)
+                return result
+
+            def to_string(self):
+                return {0: 'zero', 1: 'one', 2: 'two'}.get(self.item(), 'many')
+
+            def __str__(self):
+                if self.shape == ():
+                    return self.to_string()
+                else:
+                    fmt = {'all': lambda x: x.to_string()}
+                    return np.array2string(self, formatter=fmt)
+
+        dc = np.arange(5).view(DuckCounter)
+        assert_equal(str(dc), "[zero one two many many]")
+        assert_equal(str(dc[0]), "zero")
+
+    def test_self_containing(self):
+        arr0d = np.array(None)
+        arr0d[()] = arr0d
+        assert_equal(repr(arr0d),
+            'array(array(..., dtype=object), dtype=object)')
+        arr0d[()] = 0  # resolve recursion for garbage collector
+
+        arr1d = np.array([None, None])
+        arr1d[1] = arr1d
+        assert_equal(repr(arr1d),
+            'array([None, array(..., dtype=object)], dtype=object)')
+        arr1d[1] = 0  # resolve recursion for garbage collector
+
+        first = np.array(None)
+        second = np.array(None)
+        first[()] = second
+        second[()] = first
+        assert_equal(repr(first),
+            'array(array(array(..., dtype=object), dtype=object), dtype=object)')
+        first[()] = 0  # resolve circular references for garbage collector
+
+    def test_containing_list(self):
+        # printing square brackets directly would be ambiguuous
+        arr1d = np.array([None, None])
+        arr1d[0] = [1, 2]
+        arr1d[1] = [3]
+        assert_equal(repr(arr1d),
+            'array([list([1, 2]), list([3])], dtype=object)')
+
+    def test_void_scalar_recursion(self):
+        # gh-9345
+        repr(np.void(b'test'))  # RecursionError ?
+
+    def test_fieldless_structured(self):
+        # gh-10366
+        no_fields = np.dtype([])
+        arr_no_fields = np.empty(4, dtype=no_fields)
+        assert_equal(repr(arr_no_fields), 'array([(), (), (), ()], dtype=[])')
+
+
+class TestComplexArray:
+    def test_str(self):
+        rvals = [0, 1, -1, np.inf, -np.inf, np.nan]
+        cvals = [complex(rp, ip) for rp in rvals for ip in rvals]
+        dtypes = [np.complex64, np.cdouble, np.clongdouble]
+        actual = [str(np.array([c], dt)) for c in cvals for dt in dtypes]
+        wanted = [
+            '[0.+0.j]',    '[0.+0.j]',    '[0.+0.j]',
+            '[0.+1.j]',    '[0.+1.j]',    '[0.+1.j]',
+            '[0.-1.j]',    '[0.-1.j]',    '[0.-1.j]',
+            '[0.+infj]',   '[0.+infj]',   '[0.+infj]',
+            '[0.-infj]',   '[0.-infj]',   '[0.-infj]',
+            '[0.+nanj]',   '[0.+nanj]',   '[0.+nanj]',
+            '[1.+0.j]',    '[1.+0.j]',    '[1.+0.j]',
+            '[1.+1.j]',    '[1.+1.j]',    '[1.+1.j]',
+            '[1.-1.j]',    '[1.-1.j]',    '[1.-1.j]',
+            '[1.+infj]',   '[1.+infj]',   '[1.+infj]',
+            '[1.-infj]',   '[1.-infj]',   '[1.-infj]',
+            '[1.+nanj]',   '[1.+nanj]',   '[1.+nanj]',
+            '[-1.+0.j]',   '[-1.+0.j]',   '[-1.+0.j]',
+            '[-1.+1.j]',   '[-1.+1.j]',   '[-1.+1.j]',
+            '[-1.-1.j]',   '[-1.-1.j]',   '[-1.-1.j]',
+            '[-1.+infj]',  '[-1.+infj]',  '[-1.+infj]',
+            '[-1.-infj]',  '[-1.-infj]',  '[-1.-infj]',
+            '[-1.+nanj]',  '[-1.+nanj]',  '[-1.+nanj]',
+            '[inf+0.j]',   '[inf+0.j]',   '[inf+0.j]',
+            '[inf+1.j]',   '[inf+1.j]',   '[inf+1.j]',
+            '[inf-1.j]',   '[inf-1.j]',   '[inf-1.j]',
+            '[inf+infj]',  '[inf+infj]',  '[inf+infj]',
+            '[inf-infj]',  '[inf-infj]',  '[inf-infj]',
+            '[inf+nanj]',  '[inf+nanj]',  '[inf+nanj]',
+            '[-inf+0.j]',  '[-inf+0.j]',  '[-inf+0.j]',
+            '[-inf+1.j]',  '[-inf+1.j]',  '[-inf+1.j]',
+            '[-inf-1.j]',  '[-inf-1.j]',  '[-inf-1.j]',
+            '[-inf+infj]', '[-inf+infj]', '[-inf+infj]',
+            '[-inf-infj]', '[-inf-infj]', '[-inf-infj]',
+            '[-inf+nanj]', '[-inf+nanj]', '[-inf+nanj]',
+            '[nan+0.j]',   '[nan+0.j]',   '[nan+0.j]',
+            '[nan+1.j]',   '[nan+1.j]',   '[nan+1.j]',
+            '[nan-1.j]',   '[nan-1.j]',   '[nan-1.j]',
+            '[nan+infj]',  '[nan+infj]',  '[nan+infj]',
+            '[nan-infj]',  '[nan-infj]',  '[nan-infj]',
+            '[nan+nanj]',  '[nan+nanj]',  '[nan+nanj]']
+
+        for res, val in zip(actual, wanted):
+            assert_equal(res, val)
+
+class TestArray2String:
+    def test_basic(self):
+        """Basic test of array2string."""
+        a = np.arange(3)
+        assert_(np.array2string(a) == '[0 1 2]')
+        assert_(np.array2string(a, max_line_width=4, legacy='1.13') == '[0 1\n 2]')
+        assert_(np.array2string(a, max_line_width=4) == '[0\n 1\n 2]')
+
+    def test_unexpected_kwarg(self):
+        # ensure than an appropriate TypeError
+        # is raised when array2string receives
+        # an unexpected kwarg
+
+        with assert_raises_regex(TypeError, 'nonsense'):
+            np.array2string(np.array([1, 2, 3]),
+                            nonsense=None)
+
+    def test_format_function(self):
+        """Test custom format function for each element in array."""
+        def _format_function(x):
+            if np.abs(x) < 1:
+                return '.'
+            elif np.abs(x) < 2:
+                return 'o'
+            else:
+                return 'O'
+
+        x = np.arange(3)
+        x_hex = "[0x0 0x1 0x2]"
+        x_oct = "[0o0 0o1 0o2]"
+        assert_(np.array2string(x, formatter={'all':_format_function}) ==
+                "[. o O]")
+        assert_(np.array2string(x, formatter={'int_kind':_format_function}) ==
+                "[. o O]")
+        assert_(np.array2string(x, formatter={'all':lambda x: "%.4f" % x}) ==
+                "[0.0000 1.0000 2.0000]")
+        assert_equal(np.array2string(x, formatter={'int':lambda x: hex(x)}),
+                x_hex)
+        assert_equal(np.array2string(x, formatter={'int':lambda x: oct(x)}),
+                x_oct)
+
+        x = np.arange(3.)
+        assert_(np.array2string(x, formatter={'float_kind':lambda x: "%.2f" % x}) ==
+                "[0.00 1.00 2.00]")
+        assert_(np.array2string(x, formatter={'float':lambda x: "%.2f" % x}) ==
+                "[0.00 1.00 2.00]")
+
+        s = np.array(['abc', 'def'])
+        assert_(np.array2string(s, formatter={'numpystr':lambda s: s*2}) ==
+                '[abcabc defdef]')
+
+    def test_structure_format_mixed(self):
+        dt = np.dtype([('name', np.str_, 16), ('grades', np.float64, (2,))])
+        x = np.array([('Sarah', (8.0, 7.0)), ('John', (6.0, 7.0))], dtype=dt)
+        assert_equal(np.array2string(x),
+                "[('Sarah', [8., 7.]) ('John', [6., 7.])]")
+
+        np.set_printoptions(legacy='1.13')
+        try:
+            # for issue #5692
+            A = np.zeros(shape=10, dtype=[("A", "M8[s]")])
+            A[5:].fill(np.datetime64('NaT'))
+            assert_equal(
+                np.array2string(A),
+                textwrap.dedent("""\
+                [('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',)
+                 ('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',) ('NaT',) ('NaT',)
+                 ('NaT',) ('NaT',) ('NaT',)]""")
+            )
+        finally:
+            np.set_printoptions(legacy=False)
+
+        # same again, but with non-legacy behavior
+        assert_equal(
+            np.array2string(A),
+            textwrap.dedent("""\
+            [('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',)
+             ('1970-01-01T00:00:00',) ('1970-01-01T00:00:00',)
+             ('1970-01-01T00:00:00',) (                'NaT',)
+             (                'NaT',) (                'NaT',)
+             (                'NaT',) (                'NaT',)]""")
+        )
+
+        # and again, with timedeltas
+        A = np.full(10, 123456, dtype=[("A", "m8[s]")])
+        A[5:].fill(np.datetime64('NaT'))
+        assert_equal(
+            np.array2string(A),
+            textwrap.dedent("""\
+            [(123456,) (123456,) (123456,) (123456,) (123456,) ( 'NaT',) ( 'NaT',)
+             ( 'NaT',) ( 'NaT',) ( 'NaT',)]""")
+        )
+
+    def test_structure_format_int(self):
+        # See #8160
+        struct_int = np.array([([1, -1],), ([123, 1],)], dtype=[('B', 'i4', 2)])
+        assert_equal(np.array2string(struct_int),
+                "[([  1,  -1],) ([123,   1],)]")
+        struct_2dint = np.array([([[0, 1], [2, 3]],), ([[12, 0], [0, 0]],)],
+                dtype=[('B', 'i4', (2, 2))])
+        assert_equal(np.array2string(struct_2dint),
+                "[([[ 0,  1], [ 2,  3]],) ([[12,  0], [ 0,  0]],)]")
+
+    def test_structure_format_float(self):
+        # See #8172
+        array_scalar = np.array(
+                (1., 2.1234567890123456789, 3.), dtype=('f8,f8,f8'))
+        assert_equal(np.array2string(array_scalar), "(1., 2.12345679, 3.)")
+
+    def test_unstructured_void_repr(self):
+        a = np.array([27, 91, 50, 75,  7, 65, 10,  8,
+                      27, 91, 51, 49,109, 82,101,100], dtype='u1').view('V8')
+        assert_equal(repr(a[0]), r"void(b'\x1B\x5B\x32\x4B\x07\x41\x0A\x08')")
+        assert_equal(str(a[0]), r"b'\x1B\x5B\x32\x4B\x07\x41\x0A\x08'")
+        assert_equal(repr(a),
+            r"array([b'\x1B\x5B\x32\x4B\x07\x41\x0A\x08'," "\n"
+            r"       b'\x1B\x5B\x33\x31\x6D\x52\x65\x64'], dtype='|V8')")
+
+        assert_equal(eval(repr(a), vars(np)), a)
+        assert_equal(eval(repr(a[0]), vars(np)), a[0])
+
+    def test_edgeitems_kwarg(self):
+        # previously the global print options would be taken over the kwarg
+        arr = np.zeros(3, int)
+        assert_equal(
+            np.array2string(arr, edgeitems=1, threshold=0),
+            "[0 ... 0]"
+        )
+
+    def test_summarize_1d(self):
+        A = np.arange(1001)
+        strA = '[   0    1    2 ...  998  999 1000]'
+        assert_equal(str(A), strA)
+
+        reprA = 'array([   0,    1,    2, ...,  998,  999, 1000])'
+        assert_equal(repr(A), reprA)
+
+    def test_summarize_2d(self):
+        A = np.arange(1002).reshape(2, 501)
+        strA = '[[   0    1    2 ...  498  499  500]\n' \
+               ' [ 501  502  503 ...  999 1000 1001]]'
+        assert_equal(str(A), strA)
+
+        reprA = 'array([[   0,    1,    2, ...,  498,  499,  500],\n' \
+                '       [ 501,  502,  503, ...,  999, 1000, 1001]])'
+        assert_equal(repr(A), reprA)
+
+    def test_summarize_structure(self):
+        A = (np.arange(2002, dtype="<i8").reshape(2, 1001)
+             .view([('i', "<i8", (1001,))]))
+        strA = ("[[([   0,    1,    2, ...,  998,  999, 1000],)]\n"
+                " [([1001, 1002, 1003, ..., 1999, 2000, 2001],)]]")
+        assert_equal(str(A), strA)
+
+        reprA = ("array([[([   0,    1,    2, ...,  998,  999, 1000],)],\n"
+                 "       [([1001, 1002, 1003, ..., 1999, 2000, 2001],)]],\n"
+                 "      dtype=[('i', '<i8', (1001,))])")
+        assert_equal(repr(A), reprA)
+
+        B = np.ones(2002, dtype=">i8").view([('i', ">i8", (2, 1001))])
+        strB = "[([[1, 1, 1, ..., 1, 1, 1], [1, 1, 1, ..., 1, 1, 1]],)]"
+        assert_equal(str(B), strB)
+
+        reprB = (
+            "array([([[1, 1, 1, ..., 1, 1, 1], [1, 1, 1, ..., 1, 1, 1]],)],\n"
+            "      dtype=[('i', '>i8', (2, 1001))])"
+        )
+        assert_equal(repr(B), reprB)
+
+        C = (np.arange(22, dtype="<i8").reshape(2, 11)
+             .view([('i1', "<i8"), ('i10', "<i8", (10,))]))
+        strC = "[[( 0, [ 1, ..., 10])]\n [(11, [12, ..., 21])]]"
+        assert_equal(np.array2string(C, threshold=1, edgeitems=1), strC)
+
+    def test_linewidth(self):
+        a = np.full(6, 1)
+
+        def make_str(a, width, **kw):
+            return np.array2string(a, separator="", max_line_width=width, **kw)
+
+        assert_equal(make_str(a, 8, legacy='1.13'), '[111111]')
+        assert_equal(make_str(a, 7, legacy='1.13'), '[111111]')
+        assert_equal(make_str(a, 5, legacy='1.13'), '[1111\n'
+                                                    ' 11]')
+
+        assert_equal(make_str(a, 8), '[111111]')
+        assert_equal(make_str(a, 7), '[11111\n'
+                                     ' 1]')
+        assert_equal(make_str(a, 5), '[111\n'
+                                     ' 111]')
+
+        b = a[None,None,:]
+
+        assert_equal(make_str(b, 12, legacy='1.13'), '[[[111111]]]')
+        assert_equal(make_str(b,  9, legacy='1.13'), '[[[111111]]]')
+        assert_equal(make_str(b,  8, legacy='1.13'), '[[[11111\n'
+                                                     '   1]]]')
+
+        assert_equal(make_str(b, 12), '[[[111111]]]')
+        assert_equal(make_str(b,  9), '[[[111\n'
+                                      '   111]]]')
+        assert_equal(make_str(b,  8), '[[[11\n'
+                                      '   11\n'
+                                      '   11]]]')
+
+    def test_wide_element(self):
+        a = np.array(['xxxxx'])
+        assert_equal(
+            np.array2string(a, max_line_width=5),
+            "['xxxxx']"
+        )
+        assert_equal(
+            np.array2string(a, max_line_width=5, legacy='1.13'),
+            "[ 'xxxxx']"
+        )
+
+    def test_multiline_repr(self):
+        class MultiLine:
+            def __repr__(self):
+                return "Line 1\nLine 2"
+
+        a = np.array([[None, MultiLine()], [MultiLine(), None]])
+
+        assert_equal(
+            np.array2string(a),
+            '[[None Line 1\n'
+            '       Line 2]\n'
+            ' [Line 1\n'
+            '  Line 2 None]]'
+        )
+        assert_equal(
+            np.array2string(a, max_line_width=5),
+            '[[None\n'
+            '  Line 1\n'
+            '  Line 2]\n'
+            ' [Line 1\n'
+            '  Line 2\n'
+            '  None]]'
+        )
+        assert_equal(
+            repr(a),
+            'array([[None, Line 1\n'
+            '              Line 2],\n'
+            '       [Line 1\n'
+            '        Line 2, None]], dtype=object)'
+        )
+
+        class MultiLineLong:
+            def __repr__(self):
+                return "Line 1\nLooooooooooongestLine2\nLongerLine 3"
+
+        a = np.array([[None, MultiLineLong()], [MultiLineLong(), None]])
+        assert_equal(
+            repr(a),
+            'array([[None, Line 1\n'
+            '              LooooooooooongestLine2\n'
+            '              LongerLine 3          ],\n'
+            '       [Line 1\n'
+            '        LooooooooooongestLine2\n'
+            '        LongerLine 3          , None]], dtype=object)'
+        )
+        assert_equal(
+            np.array_repr(a, 20),
+            'array([[None,\n'
+            '        Line 1\n'
+            '        LooooooooooongestLine2\n'
+            '        LongerLine 3          ],\n'
+            '       [Line 1\n'
+            '        LooooooooooongestLine2\n'
+            '        LongerLine 3          ,\n'
+            '        None]],\n'
+            '      dtype=object)'
+        )
+
+    def test_nested_array_repr(self):
+        a = np.empty((2, 2), dtype=object)
+        a[0, 0] = np.eye(2)
+        a[0, 1] = np.eye(3)
+        a[1, 0] = None
+        a[1, 1] = np.ones((3, 1))
+        assert_equal(
+            repr(a),
+            'array([[array([[1., 0.],\n'
+            '               [0., 1.]]), array([[1., 0., 0.],\n'
+            '                                  [0., 1., 0.],\n'
+            '                                  [0., 0., 1.]])],\n'
+            '       [None, array([[1.],\n'
+            '                     [1.],\n'
+            '                     [1.]])]], dtype=object)'
+        )
+
+    @given(hynp.from_dtype(np.dtype("U")))
+    def test_any_text(self, text):
+        # This test checks that, given any value that can be represented in an
+        # array of dtype("U") (i.e. unicode string), ...
+        a = np.array([text, text, text])
+        # casting a list of them to an array does not e.g. truncate the value
+        assert_equal(a[0], text)
+        # and that np.array2string puts a newline in the expected location
+        expected_repr = "[{0!r} {0!r}\n {0!r}]".format(text)
+        result = np.array2string(a, max_line_width=len(repr(text)) * 2 + 3)
+        assert_equal(result, expected_repr)
+
+    @pytest.mark.skipif(not HAS_REFCOUNT, reason="Python lacks refcounts")
+    def test_refcount(self):
+        # make sure we do not hold references to the array due to a recursive
+        # closure (gh-10620)
+        gc.disable()
+        a = np.arange(2)
+        r1 = sys.getrefcount(a)
+        np.array2string(a)
+        np.array2string(a)
+        r2 = sys.getrefcount(a)
+        gc.collect()
+        gc.enable()
+        assert_(r1 == r2)
+
+class TestPrintOptions:
+    """Test getting and setting global print options."""
+
+    def setup_method(self):
+        self.oldopts = np.get_printoptions()
+
+    def teardown_method(self):
+        np.set_printoptions(**self.oldopts)
+
+    def test_basic(self):
+        x = np.array([1.5, 0, 1.234567890])
+        assert_equal(repr(x), "array([1.5       , 0.        , 1.23456789])")
+        np.set_printoptions(precision=4)
+        assert_equal(repr(x), "array([1.5   , 0.    , 1.2346])")
+
+    def test_precision_zero(self):
+        np.set_printoptions(precision=0)
+        for values, string in (
+                ([0.], "0."), ([.3], "0."), ([-.3], "-0."), ([.7], "1."),
+                ([1.5], "2."), ([-1.5], "-2."), ([-15.34], "-15."),
+                ([100.], "100."), ([.2, -1, 122.51], "  0.,  -1., 123."),
+                ([0], "0"), ([-12], "-12"), ([complex(.3, -.7)], "0.-1.j")):
+            x = np.array(values)
+            assert_equal(repr(x), "array([%s])" % string)
+
+    def test_formatter(self):
+        x = np.arange(3)
+        np.set_printoptions(formatter={'all':lambda x: str(x-1)})
+        assert_equal(repr(x), "array([-1, 0, 1])")
+
+    def test_formatter_reset(self):
+        x = np.arange(3)
+        np.set_printoptions(formatter={'all':lambda x: str(x-1)})
+        assert_equal(repr(x), "array([-1, 0, 1])")
+        np.set_printoptions(formatter={'int':None})
+        assert_equal(repr(x), "array([0, 1, 2])")
+
+        np.set_printoptions(formatter={'all':lambda x: str(x-1)})
+        assert_equal(repr(x), "array([-1, 0, 1])")
+        np.set_printoptions(formatter={'all':None})
+        assert_equal(repr(x), "array([0, 1, 2])")
+
+        np.set_printoptions(formatter={'int':lambda x: str(x-1)})
+        assert_equal(repr(x), "array([-1, 0, 1])")
+        np.set_printoptions(formatter={'int_kind':None})
+        assert_equal(repr(x), "array([0, 1, 2])")
+
+        x = np.arange(3.)
+        np.set_printoptions(formatter={'float':lambda x: str(x-1)})
+        assert_equal(repr(x), "array([-1.0, 0.0, 1.0])")
+        np.set_printoptions(formatter={'float_kind':None})
+        assert_equal(repr(x), "array([0., 1., 2.])")
+
+    def test_0d_arrays(self):
+        assert_equal(str(np.array('café', '<U4')), 'café')
+
+        assert_equal(repr(np.array('café', '<U4')),
+                     "array('café', dtype='<U4')")
+        assert_equal(str(np.array('test', np.str_)), 'test')
+
+        a = np.zeros(1, dtype=[('a', '<i4', (3,))])
+        assert_equal(str(a[0]), '([0, 0, 0],)')
+
+        assert_equal(repr(np.datetime64('2005-02-25')[...]),
+                     "array('2005-02-25', dtype='datetime64[D]')")
+
+        assert_equal(repr(np.timedelta64('10', 'Y')[...]),
+                     "array(10, dtype='timedelta64[Y]')")
+
+        # repr of 0d arrays is affected by printoptions
+        x = np.array(1)
+        np.set_printoptions(formatter={'all':lambda x: "test"})
+        assert_equal(repr(x), "array(test)")
+        # str is unaffected
+        assert_equal(str(x), "1")
+
+        # check `style` arg raises
+        assert_warns(DeprecationWarning, np.array2string,
+                                         np.array(1.), style=repr)
+        # but not in legacy mode
+        np.array2string(np.array(1.), style=repr, legacy='1.13')
+        # gh-10934 style was broken in legacy mode, check it works
+        np.array2string(np.array(1.), legacy='1.13')
+
+    def test_float_spacing(self):
+        x = np.array([1., 2., 3.])
+        y = np.array([1., 2., -10.])
+        z = np.array([100., 2., -1.])
+        w = np.array([-100., 2., 1.])
+
+        assert_equal(repr(x), 'array([1., 2., 3.])')
+        assert_equal(repr(y), 'array([  1.,   2., -10.])')
+        assert_equal(repr(np.array(y[0])), 'array(1.)')
+        assert_equal(repr(np.array(y[-1])), 'array(-10.)')
+        assert_equal(repr(z), 'array([100.,   2.,  -1.])')
+        assert_equal(repr(w), 'array([-100.,    2.,    1.])')
+
+        assert_equal(repr(np.array([np.nan, np.inf])), 'array([nan, inf])')
+        assert_equal(repr(np.array([np.nan, -np.inf])), 'array([ nan, -inf])')
+
+        x = np.array([np.inf, 100000, 1.1234])
+        y = np.array([np.inf, 100000, -1.1234])
+        z = np.array([np.inf, 1.1234, -1e120])
+        np.set_printoptions(precision=2)
+        assert_equal(repr(x), 'array([     inf, 1.00e+05, 1.12e+00])')
+        assert_equal(repr(y), 'array([      inf,  1.00e+05, -1.12e+00])')
+        assert_equal(repr(z), 'array([       inf,  1.12e+000, -1.00e+120])')
+
+    def test_bool_spacing(self):
+        assert_equal(repr(np.array([True,  True])),
+                     'array([ True,  True])')
+        assert_equal(repr(np.array([True, False])),
+                     'array([ True, False])')
+        assert_equal(repr(np.array([True])),
+                     'array([ True])')
+        assert_equal(repr(np.array(True)),
+                     'array(True)')
+        assert_equal(repr(np.array(False)),
+                     'array(False)')
+
+    def test_sign_spacing(self):
+        a = np.arange(4.)
+        b = np.array([1.234e9])
+        c = np.array([1.0 + 1.0j, 1.123456789 + 1.123456789j], dtype='c16')
+
+        assert_equal(repr(a), 'array([0., 1., 2., 3.])')
+        assert_equal(repr(np.array(1.)), 'array(1.)')
+        assert_equal(repr(b), 'array([1.234e+09])')
+        assert_equal(repr(np.array([0.])), 'array([0.])')
+        assert_equal(repr(c),
+            "array([1.        +1.j        , 1.12345679+1.12345679j])")
+        assert_equal(repr(np.array([0., -0.])), 'array([ 0., -0.])')
+
+        np.set_printoptions(sign=' ')
+        assert_equal(repr(a), 'array([ 0.,  1.,  2.,  3.])')
+        assert_equal(repr(np.array(1.)), 'array( 1.)')
+        assert_equal(repr(b), 'array([ 1.234e+09])')
+        assert_equal(repr(c),
+            "array([ 1.        +1.j        ,  1.12345679+1.12345679j])")
+        assert_equal(repr(np.array([0., -0.])), 'array([ 0., -0.])')
+
+        np.set_printoptions(sign='+')
+        assert_equal(repr(a), 'array([+0., +1., +2., +3.])')
+        assert_equal(repr(np.array(1.)), 'array(+1.)')
+        assert_equal(repr(b), 'array([+1.234e+09])')
+        assert_equal(repr(c),
+            "array([+1.        +1.j        , +1.12345679+1.12345679j])")
+
+        np.set_printoptions(legacy='1.13')
+        assert_equal(repr(a), 'array([ 0.,  1.,  2.,  3.])')
+        assert_equal(repr(b),  'array([  1.23400000e+09])')
+        assert_equal(repr(-b), 'array([ -1.23400000e+09])')
+        assert_equal(repr(np.array(1.)), 'array(1.0)')
+        assert_equal(repr(np.array([0.])), 'array([ 0.])')
+        assert_equal(repr(c),
+            "array([ 1.00000000+1.j        ,  1.12345679+1.12345679j])")
+        # gh-10383
+        assert_equal(str(np.array([-1., 10])), "[ -1.  10.]")
+
+        assert_raises(TypeError, np.set_printoptions, wrongarg=True)
+
+    def test_float_overflow_nowarn(self):
+        # make sure internal computations in FloatingFormat don't
+        # warn about overflow
+        repr(np.array([1e4, 0.1], dtype='f2'))
+
+    def test_sign_spacing_structured(self):
+        a = np.ones(2, dtype='<f,<f')
+        assert_equal(repr(a),
+            "array([(1., 1.), (1., 1.)], dtype=[('f0', '<f4'), ('f1', '<f4')])")
+        assert_equal(repr(a[0]), "(1., 1.)")
+
+    def test_floatmode(self):
+        x = np.array([0.6104, 0.922, 0.457, 0.0906, 0.3733, 0.007244,
+                      0.5933, 0.947, 0.2383, 0.4226], dtype=np.float16)
+        y = np.array([0.2918820979355541, 0.5064172631089138,
+                      0.2848750619642916, 0.4342965294660567,
+                      0.7326538397312751, 0.3459503329096204,
+                      0.0862072768214508, 0.39112753029631175],
+                      dtype=np.float64)
+        z = np.arange(6, dtype=np.float16)/10
+        c = np.array([1.0 + 1.0j, 1.123456789 + 1.123456789j], dtype='c16')
+
+        # also make sure 1e23 is right (is between two fp numbers)
+        w = np.array(['1e{}'.format(i) for i in range(25)], dtype=np.float64)
+        # note: we construct w from the strings `1eXX` instead of doing
+        # `10.**arange(24)` because it turns out the two are not equivalent in
+        # python. On some architectures `1e23 != 10.**23`.
+        wp = np.array([1.234e1, 1e2, 1e123])
+
+        # unique mode
+        np.set_printoptions(floatmode='unique')
+        assert_equal(repr(x),
+            "array([0.6104  , 0.922   , 0.457   , 0.0906  , 0.3733  , 0.007244,\n"
+            "       0.5933  , 0.947   , 0.2383  , 0.4226  ], dtype=float16)")
+        assert_equal(repr(y),
+            "array([0.2918820979355541 , 0.5064172631089138 , 0.2848750619642916 ,\n"
+            "       0.4342965294660567 , 0.7326538397312751 , 0.3459503329096204 ,\n"
+            "       0.0862072768214508 , 0.39112753029631175])")
+        assert_equal(repr(z),
+            "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5], dtype=float16)")
+        assert_equal(repr(w),
+            "array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,\n"
+            "       1.e+08, 1.e+09, 1.e+10, 1.e+11, 1.e+12, 1.e+13, 1.e+14, 1.e+15,\n"
+            "       1.e+16, 1.e+17, 1.e+18, 1.e+19, 1.e+20, 1.e+21, 1.e+22, 1.e+23,\n"
+            "       1.e+24])")
+        assert_equal(repr(wp), "array([1.234e+001, 1.000e+002, 1.000e+123])")
+        assert_equal(repr(c),
+            "array([1.         +1.j         , 1.123456789+1.123456789j])")
+
+        # maxprec mode, precision=8
+        np.set_printoptions(floatmode='maxprec', precision=8)
+        assert_equal(repr(x),
+            "array([0.6104  , 0.922   , 0.457   , 0.0906  , 0.3733  , 0.007244,\n"
+            "       0.5933  , 0.947   , 0.2383  , 0.4226  ], dtype=float16)")
+        assert_equal(repr(y),
+            "array([0.2918821 , 0.50641726, 0.28487506, 0.43429653, 0.73265384,\n"
+            "       0.34595033, 0.08620728, 0.39112753])")
+        assert_equal(repr(z),
+            "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5], dtype=float16)")
+        assert_equal(repr(w[::5]),
+            "array([1.e+00, 1.e+05, 1.e+10, 1.e+15, 1.e+20])")
+        assert_equal(repr(wp), "array([1.234e+001, 1.000e+002, 1.000e+123])")
+        assert_equal(repr(c),
+            "array([1.        +1.j        , 1.12345679+1.12345679j])")
+
+        # fixed mode, precision=4
+        np.set_printoptions(floatmode='fixed', precision=4)
+        assert_equal(repr(x),
+            "array([0.6104, 0.9219, 0.4570, 0.0906, 0.3733, 0.0072, 0.5933, 0.9468,\n"
+            "       0.2383, 0.4226], dtype=float16)")
+        assert_equal(repr(y),
+            "array([0.2919, 0.5064, 0.2849, 0.4343, 0.7327, 0.3460, 0.0862, 0.3911])")
+        assert_equal(repr(z),
+            "array([0.0000, 0.1000, 0.2000, 0.3000, 0.3999, 0.5000], dtype=float16)")
+        assert_equal(repr(w[::5]),
+            "array([1.0000e+00, 1.0000e+05, 1.0000e+10, 1.0000e+15, 1.0000e+20])")
+        assert_equal(repr(wp), "array([1.2340e+001, 1.0000e+002, 1.0000e+123])")
+        assert_equal(repr(np.zeros(3)), "array([0.0000, 0.0000, 0.0000])")
+        assert_equal(repr(c),
+            "array([1.0000+1.0000j, 1.1235+1.1235j])")
+        # for larger precision, representation error becomes more apparent:
+        np.set_printoptions(floatmode='fixed', precision=8)
+        assert_equal(repr(z),
+            "array([0.00000000, 0.09997559, 0.19995117, 0.30004883, 0.39990234,\n"
+            "       0.50000000], dtype=float16)")
+
+        # maxprec_equal  mode, precision=8
+        np.set_printoptions(floatmode='maxprec_equal', precision=8)
+        assert_equal(repr(x),
+            "array([0.610352, 0.921875, 0.457031, 0.090576, 0.373291, 0.007244,\n"
+            "       0.593262, 0.946777, 0.238281, 0.422607], dtype=float16)")
+        assert_equal(repr(y),
+            "array([0.29188210, 0.50641726, 0.28487506, 0.43429653, 0.73265384,\n"
+            "       0.34595033, 0.08620728, 0.39112753])")
+        assert_equal(repr(z),
+            "array([0.0, 0.1, 0.2, 0.3, 0.4, 0.5], dtype=float16)")
+        assert_equal(repr(w[::5]),
+            "array([1.e+00, 1.e+05, 1.e+10, 1.e+15, 1.e+20])")
+        assert_equal(repr(wp), "array([1.234e+001, 1.000e+002, 1.000e+123])")
+        assert_equal(repr(c),
+            "array([1.00000000+1.00000000j, 1.12345679+1.12345679j])")
+
+        # test unique special case (gh-18609)
+        a = np.float64.fromhex('-1p-97')
+        assert_equal(np.float64(np.array2string(a, floatmode='unique')), a)
+
+    def test_legacy_mode_scalars(self):
+        # in legacy mode, str of floats get truncated, and complex scalars
+        # use * for non-finite imaginary part
+        np.set_printoptions(legacy='1.13')
+        assert_equal(str(np.float64(1.123456789123456789)), '1.12345678912')
+        assert_equal(str(np.complex128(complex(1, np.nan))), '(1+nan*j)')
+
+        np.set_printoptions(legacy=False)
+        assert_equal(str(np.float64(1.123456789123456789)),
+                     '1.1234567891234568')
+        assert_equal(str(np.complex128(complex(1, np.nan))), '(1+nanj)')
+
+    def test_legacy_stray_comma(self):
+        np.set_printoptions(legacy='1.13')
+        assert_equal(str(np.arange(10000)), '[   0    1    2 ..., 9997 9998 9999]')
+
+        np.set_printoptions(legacy=False)
+        assert_equal(str(np.arange(10000)), '[   0    1    2 ... 9997 9998 9999]')
+
+    def test_dtype_linewidth_wrapping(self):
+        np.set_printoptions(linewidth=75)
+        assert_equal(repr(np.arange(10,20., dtype='f4')),
+            "array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19.], dtype=float32)")
+        assert_equal(repr(np.arange(10,23., dtype='f4')), textwrap.dedent("""\
+            array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.],
+                  dtype=float32)"""))
+
+        styp = '<U4'
+        assert_equal(repr(np.ones(3, dtype=styp)),
+            "array(['1', '1', '1'], dtype='{}')".format(styp))
+        assert_equal(repr(np.ones(12, dtype=styp)), textwrap.dedent("""\
+            array(['1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1'],
+                  dtype='{}')""".format(styp)))
+
+    @pytest.mark.parametrize(
+        ['native'],
+        [
+            ('bool',),
+            ('uint8',),
+            ('uint16',),
+            ('uint32',),
+            ('uint64',),
+            ('int8',),
+            ('int16',),
+            ('int32',),
+            ('int64',),
+            ('float16',),
+            ('float32',),
+            ('float64',),
+            ('U1',),     # 4-byte width string
+        ],
+    )
+    def test_dtype_endianness_repr(self, native):
+        '''
+        there was an issue where
+        repr(array([0], dtype='<u2')) and repr(array([0], dtype='>u2'))
+        both returned the same thing:
+        array([0], dtype=uint16)
+        even though their dtypes have different endianness.
+        '''
+        native_dtype = np.dtype(native)
+        non_native_dtype = native_dtype.newbyteorder()
+        non_native_repr = repr(np.array([1], non_native_dtype))
+        native_repr = repr(np.array([1], native_dtype))
+        # preserve the sensible default of only showing dtype if nonstandard
+        assert ('dtype' in native_repr) ^ (native_dtype in _typelessdata),\
+                ("an array's repr should show dtype if and only if the type "
+                 'of the array is NOT one of the standard types '
+                 '(e.g., int32, bool, float64).')
+        if non_native_dtype.itemsize > 1:
+            # if the type is >1 byte, the non-native endian version
+            # must show endianness.
+            assert non_native_repr != native_repr
+            assert f"dtype='{non_native_dtype.byteorder}" in non_native_repr
+
+    def test_linewidth_repr(self):
+        a = np.full(7, fill_value=2)
+        np.set_printoptions(linewidth=17)
+        assert_equal(
+            repr(a),
+            textwrap.dedent("""\
+            array([2, 2, 2,
+                   2, 2, 2,
+                   2])""")
+        )
+        np.set_printoptions(linewidth=17, legacy='1.13')
+        assert_equal(
+            repr(a),
+            textwrap.dedent("""\
+            array([2, 2, 2,
+                   2, 2, 2, 2])""")
+        )
+
+        a = np.full(8, fill_value=2)
+
+        np.set_printoptions(linewidth=18, legacy=False)
+        assert_equal(
+            repr(a),
+            textwrap.dedent("""\
+            array([2, 2, 2,
+                   2, 2, 2,
+                   2, 2])""")
+        )
+
+        np.set_printoptions(linewidth=18, legacy='1.13')
+        assert_equal(
+            repr(a),
+            textwrap.dedent("""\
+            array([2, 2, 2, 2,
+                   2, 2, 2, 2])""")
+        )
+
+    def test_linewidth_str(self):
+        a = np.full(18, fill_value=2)
+        np.set_printoptions(linewidth=18)
+        assert_equal(
+            str(a),
+            textwrap.dedent("""\
+            [2 2 2 2 2 2 2 2
+             2 2 2 2 2 2 2 2
+             2 2]""")
+        )
+        np.set_printoptions(linewidth=18, legacy='1.13')
+        assert_equal(
+            str(a),
+            textwrap.dedent("""\
+            [2 2 2 2 2 2 2 2 2
+             2 2 2 2 2 2 2 2 2]""")
+        )
+
+    def test_edgeitems(self):
+        np.set_printoptions(edgeitems=1, threshold=1)
+        a = np.arange(27).reshape((3, 3, 3))
+        assert_equal(
+            repr(a),
+            textwrap.dedent("""\
+            array([[[ 0, ...,  2],
+                    ...,
+                    [ 6, ...,  8]],
+
+                   ...,
+
+                   [[18, ..., 20],
+                    ...,
+                    [24, ..., 26]]])""")
+        )
+
+        b = np.zeros((3, 3, 1, 1))
+        assert_equal(
+            repr(b),
+            textwrap.dedent("""\
+            array([[[[0.]],
+
+                    ...,
+
+                    [[0.]]],
+
+
+                   ...,
+
+
+                   [[[0.]],
+
+                    ...,
+
+                    [[0.]]]])""")
+        )
+
+        # 1.13 had extra trailing spaces, and was missing newlines
+        np.set_printoptions(legacy='1.13')
+
+        assert_equal(
+            repr(a),
+            textwrap.dedent("""\
+            array([[[ 0, ...,  2],
+                    ..., 
+                    [ 6, ...,  8]],
+
+                   ..., 
+                   [[18, ..., 20],
+                    ..., 
+                    [24, ..., 26]]])""")
+        )
+
+        assert_equal(
+            repr(b),
+            textwrap.dedent("""\
+            array([[[[ 0.]],
+
+                    ..., 
+                    [[ 0.]]],
+
+
+                   ..., 
+                   [[[ 0.]],
+
+                    ..., 
+                    [[ 0.]]]])""")
+        )
+
+    def test_edgeitems_structured(self):
+        np.set_printoptions(edgeitems=1, threshold=1)
+        A = np.arange(5*2*3, dtype="<i8").view([('i', "<i8", (5, 2, 3))])
+        reprA = (
+            "array([([[[ 0, ...,  2], [ 3, ...,  5]], ..., "
+            "[[24, ..., 26], [27, ..., 29]]],)],\n"
+            "      dtype=[('i', '<i8', (5, 2, 3))])"
+        )
+        assert_equal(repr(A), reprA)
+
+    def test_bad_args(self):
+        assert_raises(ValueError, np.set_printoptions, threshold=float('nan'))
+        assert_raises(TypeError, np.set_printoptions, threshold='1')
+        assert_raises(TypeError, np.set_printoptions, threshold=b'1')
+
+        assert_raises(TypeError, np.set_printoptions, precision='1')
+        assert_raises(TypeError, np.set_printoptions, precision=1.5)
+
+def test_unicode_object_array():
+    expected = "array(['é'], dtype=object)"
+    x = np.array(['\xe9'], dtype=object)
+    assert_equal(repr(x), expected)
+
+
+class TestContextManager:
+    def test_ctx_mgr(self):
+        # test that context manager actually works
+        with np.printoptions(precision=2):
+            s = str(np.array([2.0]) / 3)
+        assert_equal(s, '[0.67]')
+
+    def test_ctx_mgr_restores(self):
+        # test that print options are actually restrored
+        opts = np.get_printoptions()
+        with np.printoptions(precision=opts['precision'] - 1,
+                             linewidth=opts['linewidth'] - 4):
+            pass
+        assert_equal(np.get_printoptions(), opts)
+
+    def test_ctx_mgr_exceptions(self):
+        # test that print options are restored even if an exception is raised
+        opts = np.get_printoptions()
+        try:
+            with np.printoptions(precision=2, linewidth=11):
+                raise ValueError
+        except ValueError:
+            pass
+        assert_equal(np.get_printoptions(), opts)
+
+    def test_ctx_mgr_as_smth(self):
+        opts = {"precision": 2}
+        with np.printoptions(**opts) as ctx:
+            saved_opts = ctx.copy()
+        assert_equal({k: saved_opts[k] for k in opts}, opts)

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/test_casting_floatingpoint_errors.py

@@ -0,0 +1,154 @@
+import pytest
+from pytest import param
+from numpy.testing import IS_WASM
+import numpy as np
+
+
+def values_and_dtypes():
+    """
+    Generate value+dtype pairs that generate floating point errors during
+    casts.  The invalid casts to integers will generate "invalid" value
+    warnings, the float casts all generate "overflow".
+
+    (The Python int/float paths don't need to get tested in all the same
+    situations, but it does not hurt.)
+    """
+    # Casting to float16:
+    yield param(70000, "float16", id="int-to-f2")
+    yield param("70000", "float16", id="str-to-f2")
+    yield param(70000.0, "float16", id="float-to-f2")
+    yield param(np.longdouble(70000.), "float16", id="longdouble-to-f2")
+    yield param(np.float64(70000.), "float16", id="double-to-f2")
+    yield param(np.float32(70000.), "float16", id="float-to-f2")
+    # Casting to float32:
+    yield param(10**100, "float32", id="int-to-f4")
+    yield param(1e100, "float32", id="float-to-f2")
+    yield param(np.longdouble(1e300), "float32", id="longdouble-to-f2")
+    yield param(np.float64(1e300), "float32", id="double-to-f2")
+    # Casting to float64:
+    # If longdouble is double-double, its max can be rounded down to the double
+    # max.  So we correct the double spacing (a bit weird, admittedly):
+    max_ld = np.finfo(np.longdouble).max
+    spacing = np.spacing(np.nextafter(np.finfo("f8").max, 0))
+    if max_ld - spacing > np.finfo("f8").max:
+        yield param(np.finfo(np.longdouble).max, "float64",
+                    id="longdouble-to-f8")
+
+    # Cast to complex32:
+    yield param(2e300, "complex64", id="float-to-c8")
+    yield param(2e300+0j, "complex64", id="complex-to-c8")
+    yield param(2e300j, "complex64", id="complex-to-c8")
+    yield param(np.longdouble(2e300), "complex64", id="longdouble-to-c8")
+
+    # Invalid float to integer casts:
+    with np.errstate(over="ignore"):
+        for to_dt in np.typecodes["AllInteger"]:
+            for value in [np.inf, np.nan]:
+                for from_dt in np.typecodes["AllFloat"]:
+                    from_dt = np.dtype(from_dt)
+                    from_val = from_dt.type(value)
+
+                    yield param(from_val, to_dt, id=f"{from_val}-to-{to_dt}")
+
+
+def check_operations(dtype, value):
+    """
+    There are many dedicated paths in NumPy which cast and should check for
+    floating point errors which occurred during those casts.
+    """
+    if dtype.kind != 'i':
+        # These assignments use the stricter setitem logic:
+        def assignment():
+            arr = np.empty(3, dtype=dtype)
+            arr[0] = value
+
+        yield assignment
+
+        def fill():
+            arr = np.empty(3, dtype=dtype)
+            arr.fill(value)
+
+        yield fill
+
+    def copyto_scalar():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, value, casting="unsafe")
+
+    yield copyto_scalar
+
+    def copyto():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, np.array([value, value, value]), casting="unsafe")
+
+    yield copyto
+
+    def copyto_scalar_masked():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, value, casting="unsafe",
+                  where=[True, False, True])
+
+    yield copyto_scalar_masked
+
+    def copyto_masked():
+        arr = np.empty(3, dtype=dtype)
+        np.copyto(arr, np.array([value, value, value]), casting="unsafe",
+                  where=[True, False, True])
+
+    yield copyto_masked
+
+    def direct_cast():
+        np.array([value, value, value]).astype(dtype)
+
+    yield direct_cast
+
+    def direct_cast_nd_strided():
+        arr = np.full((5, 5, 5), fill_value=value)[:, ::2, :]
+        arr.astype(dtype)
+
+    yield direct_cast_nd_strided
+
+    def boolean_array_assignment():
+        arr = np.empty(3, dtype=dtype)
+        arr[[True, False, True]] = np.array([value, value])
+
+    yield boolean_array_assignment
+
+    def integer_array_assignment():
+        arr = np.empty(3, dtype=dtype)
+        values = np.array([value, value])
+
+        arr[[0, 1]] = values
+
+    yield integer_array_assignment
+
+    def integer_array_assignment_with_subspace():
+        arr = np.empty((5, 3), dtype=dtype)
+        values = np.array([value, value, value])
+
+        arr[[0, 2]] = values
+
+    yield integer_array_assignment_with_subspace
+
+    def flat_assignment():
+        arr = np.empty((3,), dtype=dtype)
+        values = np.array([value, value, value])
+        arr.flat[:] = values
+
+    yield flat_assignment
+
+@pytest.mark.skipif(IS_WASM, reason="no wasm fp exception support")
+@pytest.mark.parametrize(["value", "dtype"], values_and_dtypes())
+@pytest.mark.filterwarnings("ignore::numpy.ComplexWarning")
+def test_floatingpoint_errors_casting(dtype, value):
+    dtype = np.dtype(dtype)
+    for operation in check_operations(dtype, value):
+        dtype = np.dtype(dtype)
+
+        match = "invalid" if dtype.kind in 'iu' else "overflow"
+        with pytest.warns(RuntimeWarning, match=match):
+            operation()
+
+        with np.errstate(all="raise"):
+            with pytest.raises(FloatingPointError, match=match):
+                operation()
+

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/test_memmap.py

@@ -0,0 +1,215 @@
+import sys
+import os
+import mmap
+import pytest
+from pathlib import Path
+from tempfile import NamedTemporaryFile, TemporaryFile
+
+from numpy import (
+    memmap, sum, average, prod, ndarray, isscalar, add, subtract, multiply)
+
+from numpy import arange, allclose, asarray
+from numpy.testing import (
+    assert_, assert_equal, assert_array_equal, suppress_warnings, IS_PYPY,
+    break_cycles
+    )
+
+class TestMemmap:
+    def setup_method(self):
+        self.tmpfp = NamedTemporaryFile(prefix='mmap')
+        self.shape = (3, 4)
+        self.dtype = 'float32'
+        self.data = arange(12, dtype=self.dtype)
+        self.data.resize(self.shape)
+
+    def teardown_method(self):
+        self.tmpfp.close()
+        self.data = None
+        if IS_PYPY:
+            break_cycles()
+            break_cycles()
+
+    def test_roundtrip(self):
+        # Write data to file
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        fp[:] = self.data[:]
+        del fp  # Test __del__ machinery, which handles cleanup
+
+        # Read data back from file
+        newfp = memmap(self.tmpfp, dtype=self.dtype, mode='r',
+                       shape=self.shape)
+        assert_(allclose(self.data, newfp))
+        assert_array_equal(self.data, newfp)
+        assert_equal(newfp.flags.writeable, False)
+
+    def test_open_with_filename(self, tmp_path):
+        tmpname = tmp_path / 'mmap'
+        fp = memmap(tmpname, dtype=self.dtype, mode='w+',
+                       shape=self.shape)
+        fp[:] = self.data[:]
+        del fp
+
+    def test_unnamed_file(self):
+        with TemporaryFile() as f:
+            fp = memmap(f, dtype=self.dtype, shape=self.shape)
+            del fp
+
+    def test_attributes(self):
+        offset = 1
+        mode = "w+"
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode=mode,
+                    shape=self.shape, offset=offset)
+        assert_equal(offset, fp.offset)
+        assert_equal(mode, fp.mode)
+        del fp
+
+    def test_filename(self, tmp_path):
+        tmpname = tmp_path / "mmap"
+        fp = memmap(tmpname, dtype=self.dtype, mode='w+',
+                       shape=self.shape)
+        abspath = Path(os.path.abspath(tmpname))
+        fp[:] = self.data[:]
+        assert_equal(abspath, fp.filename)
+        b = fp[:1]
+        assert_equal(abspath, b.filename)
+        del b
+        del fp
+
+    def test_path(self, tmp_path):
+        tmpname = tmp_path / "mmap"
+        fp = memmap(Path(tmpname), dtype=self.dtype, mode='w+',
+                       shape=self.shape)
+        # os.path.realpath does not resolve symlinks on Windows
+        # see: https://bugs.python.org/issue9949
+        # use Path.resolve, just as memmap class does internally
+        abspath = str(Path(tmpname).resolve())
+        fp[:] = self.data[:]
+        assert_equal(abspath, str(fp.filename.resolve()))
+        b = fp[:1]
+        assert_equal(abspath, str(b.filename.resolve()))
+        del b
+        del fp
+
+    def test_filename_fileobj(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode="w+",
+                    shape=self.shape)
+        assert_equal(fp.filename, self.tmpfp.name)
+
+    @pytest.mark.skipif(sys.platform == 'gnu0',
+                        reason="Known to fail on hurd")
+    def test_flush(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        fp[:] = self.data[:]
+        assert_equal(fp[0], self.data[0])
+        fp.flush()
+
+    def test_del(self):
+        # Make sure a view does not delete the underlying mmap
+        fp_base = memmap(self.tmpfp, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        fp_base[0] = 5
+        fp_view = fp_base[0:1]
+        assert_equal(fp_view[0], 5)
+        del fp_view
+        # Should still be able to access and assign values after
+        # deleting the view
+        assert_equal(fp_base[0], 5)
+        fp_base[0] = 6
+        assert_equal(fp_base[0], 6)
+
+    def test_arithmetic_drops_references(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        tmp = (fp + 10)
+        if isinstance(tmp, memmap):
+            assert_(tmp._mmap is not fp._mmap)
+
+    def test_indexing_drops_references(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        tmp = fp[(1, 2), (2, 3)]
+        if isinstance(tmp, memmap):
+            assert_(tmp._mmap is not fp._mmap)
+
+    def test_slicing_keeps_references(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+',
+                    shape=self.shape)
+        assert_(fp[:2, :2]._mmap is fp._mmap)
+
+    def test_view(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, shape=self.shape)
+        new1 = fp.view()
+        new2 = new1.view()
+        assert_(new1.base is fp)
+        assert_(new2.base is fp)
+        new_array = asarray(fp)
+        assert_(new_array.base is fp)
+
+    def test_ufunc_return_ndarray(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, shape=self.shape)
+        fp[:] = self.data
+
+        with suppress_warnings() as sup:
+            sup.filter(FutureWarning, "np.average currently does not preserve")
+            for unary_op in [sum, average, prod]:
+                result = unary_op(fp)
+                assert_(isscalar(result))
+                assert_(result.__class__ is self.data[0, 0].__class__)
+
+                assert_(unary_op(fp, axis=0).__class__ is ndarray)
+                assert_(unary_op(fp, axis=1).__class__ is ndarray)
+
+        for binary_op in [add, subtract, multiply]:
+            assert_(binary_op(fp, self.data).__class__ is ndarray)
+            assert_(binary_op(self.data, fp).__class__ is ndarray)
+            assert_(binary_op(fp, fp).__class__ is ndarray)
+
+        fp += 1
+        assert(fp.__class__ is memmap)
+        add(fp, 1, out=fp)
+        assert(fp.__class__ is memmap)
+
+    def test_getitem(self):
+        fp = memmap(self.tmpfp, dtype=self.dtype, shape=self.shape)
+        fp[:] = self.data
+
+        assert_(fp[1:, :-1].__class__ is memmap)
+        # Fancy indexing returns a copy that is not memmapped
+        assert_(fp[[0, 1]].__class__ is ndarray)
+
+    def test_memmap_subclass(self):
+        class MemmapSubClass(memmap):
+            pass
+
+        fp = MemmapSubClass(self.tmpfp, dtype=self.dtype, shape=self.shape)
+        fp[:] = self.data
+
+        # We keep previous behavior for subclasses of memmap, i.e. the
+        # ufunc and __getitem__ output is never turned into a ndarray
+        assert_(sum(fp, axis=0).__class__ is MemmapSubClass)
+        assert_(sum(fp).__class__ is MemmapSubClass)
+        assert_(fp[1:, :-1].__class__ is MemmapSubClass)
+        assert(fp[[0, 1]].__class__ is MemmapSubClass)
+
+    def test_mmap_offset_greater_than_allocation_granularity(self):
+        size = 5 * mmap.ALLOCATIONGRANULARITY
+        offset = mmap.ALLOCATIONGRANULARITY + 1
+        fp = memmap(self.tmpfp, shape=size, mode='w+', offset=offset)
+        assert_(fp.offset == offset)
+
+    def test_no_shape(self):
+        self.tmpfp.write(b'a'*16)
+        mm = memmap(self.tmpfp, dtype='float64')
+        assert_equal(mm.shape, (2,))
+
+    def test_empty_array(self):
+        # gh-12653
+        with pytest.raises(ValueError, match='empty file'):
+            memmap(self.tmpfp, shape=(0,4), mode='w+')
+
+        self.tmpfp.write(b'\0')
+
+        # ok now the file is not empty
+        memmap(self.tmpfp, shape=(0,4), mode='w+')

env-llmeval/lib/python3.10/site-packages/numpy/core/tests/test_scalarprint.py

@@ -0,0 +1,382 @@
+""" Test printing of scalar types.
+
+"""
+import code
+import platform
+import pytest
+import sys
+
+from tempfile import TemporaryFile
+import numpy as np
+from numpy.testing import assert_, assert_equal, assert_raises, IS_MUSL
+
+class TestRealScalars:
+    def test_str(self):
+        svals = [0.0, -0.0, 1, -1, np.inf, -np.inf, np.nan]
+        styps = [np.float16, np.float32, np.float64, np.longdouble]
+        wanted = [
+             ['0.0',  '0.0',  '0.0',  '0.0' ],
+             ['-0.0', '-0.0', '-0.0', '-0.0'],
+             ['1.0',  '1.0',  '1.0',  '1.0' ],
+             ['-1.0', '-1.0', '-1.0', '-1.0'],
+             ['inf',  'inf',  'inf',  'inf' ],
+             ['-inf', '-inf', '-inf', '-inf'],
+             ['nan',  'nan',  'nan',  'nan']]
+
+        for wants, val in zip(wanted, svals):
+            for want, styp in zip(wants, styps):
+                msg = 'for str({}({}))'.format(np.dtype(styp).name, repr(val))
+                assert_equal(str(styp(val)), want, err_msg=msg)
+
+    def test_scalar_cutoffs(self):
+        # test that both the str and repr of np.float64 behaves
+        # like python floats in python3.
+        def check(v):
+            assert_equal(str(np.float64(v)), str(v))
+            assert_equal(str(np.float64(v)), repr(v))
+            assert_equal(repr(np.float64(v)), repr(v))
+            assert_equal(repr(np.float64(v)), str(v))
+
+        # check we use the same number of significant digits
+        check(1.12345678901234567890)
+        check(0.0112345678901234567890)
+
+        # check switch from scientific output to positional and back
+        check(1e-5)
+        check(1e-4)
+        check(1e15)
+        check(1e16)
+
+    def test_py2_float_print(self):
+        # gh-10753
+        # In python2, the python float type implements an obsolete method
+        # tp_print, which overrides tp_repr and tp_str when using "print" to
+        # output to a "real file" (ie, not a StringIO). Make sure we don't
+        # inherit it.
+        x = np.double(0.1999999999999)
+        with TemporaryFile('r+t') as f:
+            print(x, file=f)
+            f.seek(0)
+            output = f.read()
+        assert_equal(output, str(x) + '\n')
+        # In python2 the value float('0.1999999999999') prints with reduced
+        # precision as '0.2', but we want numpy's np.double('0.1999999999999')
+        # to print the unique value, '0.1999999999999'.
+
+        # gh-11031
+        # Only in the python2 interactive shell and when stdout is a "real"
+        # file, the output of the last command is printed to stdout without
+        # Py_PRINT_RAW (unlike the print statement) so `>>> x` and `>>> print
+        # x` are potentially different. Make sure they are the same. The only
+        # way I found to get prompt-like output is using an actual prompt from
+        # the 'code' module. Again, must use tempfile to get a "real" file.
+
+        # dummy user-input which enters one line and then ctrl-Ds.
+        def userinput():
+            yield 'np.sqrt(2)'
+            raise EOFError
+        gen = userinput()
+        input_func = lambda prompt="": next(gen)
+
+        with TemporaryFile('r+t') as fo, TemporaryFile('r+t') as fe:
+            orig_stdout, orig_stderr = sys.stdout, sys.stderr
+            sys.stdout, sys.stderr = fo, fe
+
+            code.interact(local={'np': np}, readfunc=input_func, banner='')
+
+            sys.stdout, sys.stderr = orig_stdout, orig_stderr
+
+            fo.seek(0)
+            capture = fo.read().strip()
+
+        assert_equal(capture, repr(np.sqrt(2)))
+
+    def test_dragon4(self):
+        # these tests are adapted from Ryan Juckett's dragon4 implementation,
+        # see dragon4.c for details.
+
+        fpos32 = lambda x, **k: np.format_float_positional(np.float32(x), **k)
+        fsci32 = lambda x, **k: np.format_float_scientific(np.float32(x), **k)
+        fpos64 = lambda x, **k: np.format_float_positional(np.float64(x), **k)
+        fsci64 = lambda x, **k: np.format_float_scientific(np.float64(x), **k)
+
+        preckwd = lambda prec: {'unique': False, 'precision': prec}
+
+        assert_equal(fpos32('1.0'), "1.")
+        assert_equal(fsci32('1.0'), "1.e+00")
+        assert_equal(fpos32('10.234'), "10.234")
+        assert_equal(fpos32('-10.234'), "-10.234")
+        assert_equal(fsci32('10.234'), "1.0234e+01")
+        assert_equal(fsci32('-10.234'), "-1.0234e+01")
+        assert_equal(fpos32('1000.0'), "1000.")
+        assert_equal(fpos32('1.0', precision=0), "1.")
+        assert_equal(fsci32('1.0', precision=0), "1.e+00")
+        assert_equal(fpos32('10.234', precision=0), "10.")
+        assert_equal(fpos32('-10.234', precision=0), "-10.")
+        assert_equal(fsci32('10.234', precision=0), "1.e+01")
+        assert_equal(fsci32('-10.234', precision=0), "-1.e+01")
+        assert_equal(fpos32('10.234', precision=2), "10.23")
+        assert_equal(fsci32('-10.234', precision=2), "-1.02e+01")
+        assert_equal(fsci64('9.9999999999999995e-08', **preckwd(16)),
+                            '9.9999999999999995e-08')
+        assert_equal(fsci64('9.8813129168249309e-324', **preckwd(16)),
+                            '9.8813129168249309e-324')
+        assert_equal(fsci64('9.9999999999999694e-311', **preckwd(16)),
+                            '9.9999999999999694e-311')
+
+
+        # test rounding
+        # 3.1415927410 is closest float32 to np.pi
+        assert_equal(fpos32('3.14159265358979323846', **preckwd(10)),
+                            "3.1415927410")
+        assert_equal(fsci32('3.14159265358979323846', **preckwd(10)),
+                            "3.1415927410e+00")
+        assert_equal(fpos64('3.14159265358979323846', **preckwd(10)),
+                            "3.1415926536")
+        assert_equal(fsci64('3.14159265358979323846', **preckwd(10)),
+                            "3.1415926536e+00")
+        # 299792448 is closest float32 to 299792458
+        assert_equal(fpos32('299792458.0', **preckwd(5)), "299792448.00000")
+        assert_equal(fsci32('299792458.0', **preckwd(5)), "2.99792e+08")
+        assert_equal(fpos64('299792458.0', **preckwd(5)), "299792458.00000")
+        assert_equal(fsci64('299792458.0', **preckwd(5)), "2.99792e+08")
+
+        assert_equal(fpos32('3.14159265358979323846', **preckwd(25)),
+                            "3.1415927410125732421875000")
+        assert_equal(fpos64('3.14159265358979323846', **preckwd(50)),
+                         "3.14159265358979311599796346854418516159057617187500")
+        assert_equal(fpos64('3.14159265358979323846'), "3.141592653589793")
+
+
+        # smallest numbers
+        assert_equal(fpos32(0.5**(126 + 23), unique=False, precision=149),
+                    "0.00000000000000000000000000000000000000000000140129846432"
+                    "4817070923729583289916131280261941876515771757068283889791"
+                    "08268586060148663818836212158203125")
+        
+        assert_equal(fpos64(5e-324, unique=False, precision=1074),
+                    "0.00000000000000000000000000000000000000000000000000000000"
+                    "0000000000000000000000000000000000000000000000000000000000"
+                    "0000000000000000000000000000000000000000000000000000000000"
+                    "0000000000000000000000000000000000000000000000000000000000"
+                    "0000000000000000000000000000000000000000000000000000000000"
+                    "0000000000000000000000000000000000049406564584124654417656"
+                    "8792868221372365059802614324764425585682500675507270208751"
+                    "8652998363616359923797965646954457177309266567103559397963"
+                    "9877479601078187812630071319031140452784581716784898210368"
+                    "8718636056998730723050006387409153564984387312473397273169"
+                    "6151400317153853980741262385655911710266585566867681870395"
+                    "6031062493194527159149245532930545654440112748012970999954"
+                    "1931989409080416563324524757147869014726780159355238611550"
+                    "1348035264934720193790268107107491703332226844753335720832"
+                    "4319360923828934583680601060115061698097530783422773183292"
+                    "4790498252473077637592724787465608477820373446969953364701"
+                    "7972677717585125660551199131504891101451037862738167250955"
+                    "8373897335989936648099411642057026370902792427675445652290"
+                    "87538682506419718265533447265625")
+
+        # largest numbers
+        f32x = np.finfo(np.float32).max
+        assert_equal(fpos32(f32x, **preckwd(0)),
+                    "340282346638528859811704183484516925440.")
+        assert_equal(fpos64(np.finfo(np.float64).max, **preckwd(0)),
+                    "1797693134862315708145274237317043567980705675258449965989"
+                    "1747680315726078002853876058955863276687817154045895351438"
+                    "2464234321326889464182768467546703537516986049910576551282"
+                    "0762454900903893289440758685084551339423045832369032229481"
+                    "6580855933212334827479782620414472316873817718091929988125"
+                    "0404026184124858368.")
+        # Warning: In unique mode only the integer digits necessary for
+        # uniqueness are computed, the rest are 0.
+        assert_equal(fpos32(f32x),
+                    "340282350000000000000000000000000000000.")
+
+        # Further tests of zero-padding vs rounding in different combinations
+        # of unique, fractional, precision, min_digits
+        # precision can only reduce digits, not add them.
+        # min_digits can only extend digits, not reduce them.
+        assert_equal(fpos32(f32x, unique=True, fractional=True, precision=0),
+                    "340282350000000000000000000000000000000.")
+        assert_equal(fpos32(f32x, unique=True, fractional=True, precision=4),
+                    "340282350000000000000000000000000000000.")
+        assert_equal(fpos32(f32x, unique=True, fractional=True, min_digits=0),
+                    "340282346638528859811704183484516925440.")
+        assert_equal(fpos32(f32x, unique=True, fractional=True, min_digits=4),
+                    "340282346638528859811704183484516925440.0000")
+        assert_equal(fpos32(f32x, unique=True, fractional=True,
+                                    min_digits=4, precision=4),
+                    "340282346638528859811704183484516925440.0000")
+        assert_raises(ValueError, fpos32, f32x, unique=True, fractional=False,
+                                          precision=0)
+        assert_equal(fpos32(f32x, unique=True, fractional=False, precision=4),
+                    "340300000000000000000000000000000000000.")
+        assert_equal(fpos32(f32x, unique=True, fractional=False, precision=20),
+                    "340282350000000000000000000000000000000.")
+        assert_equal(fpos32(f32x, unique=True, fractional=False, min_digits=4),
+                    "340282350000000000000000000000000000000.")
+        assert_equal(fpos32(f32x, unique=True, fractional=False,
+                                  min_digits=20),
+                    "340282346638528859810000000000000000000.")
+        assert_equal(fpos32(f32x, unique=True, fractional=False,
+                                  min_digits=15),
+                    "340282346638529000000000000000000000000.")
+        assert_equal(fpos32(f32x, unique=False, fractional=False, precision=4),
+                    "340300000000000000000000000000000000000.")
+        # test that unique rounding is preserved when precision is supplied
+        # but no extra digits need to be printed (gh-18609)
+        a = np.float64.fromhex('-1p-97')
+        assert_equal(fsci64(a, unique=True), '-6.310887241768095e-30')
+        assert_equal(fsci64(a, unique=False, precision=15),
+                     '-6.310887241768094e-30')
+        assert_equal(fsci64(a, unique=True, precision=15),
+                     '-6.310887241768095e-30')
+        assert_equal(fsci64(a, unique=True, min_digits=15),
+                     '-6.310887241768095e-30')
+        assert_equal(fsci64(a, unique=True, precision=15, min_digits=15),
+                     '-6.310887241768095e-30')
+        # adds/remove digits in unique mode with unbiased rnding
+        assert_equal(fsci64(a, unique=True, precision=14),
+                     '-6.31088724176809e-30')
+        assert_equal(fsci64(a, unique=True, min_digits=16),
+                     '-6.3108872417680944e-30')
+        assert_equal(fsci64(a, unique=True, precision=16),
+                     '-6.310887241768095e-30')
+        assert_equal(fsci64(a, unique=True, min_digits=14),
+                     '-6.310887241768095e-30')
+        # test min_digits in unique mode with different rounding cases
+        assert_equal(fsci64('1e120', min_digits=3), '1.000e+120')
+        assert_equal(fsci64('1e100', min_digits=3), '1.000e+100')
+
+        # test trailing zeros
+        assert_equal(fpos32('1.0', unique=False, precision=3), "1.000")
+        assert_equal(fpos64('1.0', unique=False, precision=3), "1.000")
+        assert_equal(fsci32('1.0', unique=False, precision=3), "1.000e+00")
+        assert_equal(fsci64('1.0', unique=False, precision=3), "1.000e+00")
+        assert_equal(fpos32('1.5', unique=False, precision=3), "1.500")
+        assert_equal(fpos64('1.5', unique=False, precision=3), "1.500")
+        assert_equal(fsci32('1.5', unique=False, precision=3), "1.500e+00")
+        assert_equal(fsci64('1.5', unique=False, precision=3), "1.500e+00")
+        # gh-10713
+        assert_equal(fpos64('324', unique=False, precision=5,
+                                   fractional=False), "324.00")
+
+    def test_dragon4_interface(self):
+        tps = [np.float16, np.float32, np.float64]
+        # test is flaky for musllinux on np.float128
+        if hasattr(np, 'float128') and not IS_MUSL:
+            tps.append(np.float128)
+
+        fpos = np.format_float_positional
+        fsci = np.format_float_scientific
+
+        for tp in tps:
+            # test padding
+            assert_equal(fpos(tp('1.0'), pad_left=4, pad_right=4), "   1.    ")
+            assert_equal(fpos(tp('-1.0'), pad_left=4, pad_right=4), "  -1.    ")
+            assert_equal(fpos(tp('-10.2'),
+                         pad_left=4, pad_right=4), " -10.2   ")
+
+            # test exp_digits
+            assert_equal(fsci(tp('1.23e1'), exp_digits=5), "1.23e+00001")
+
+            # test fixed (non-unique) mode
+            assert_equal(fpos(tp('1.0'), unique=False, precision=4), "1.0000")
+            assert_equal(fsci(tp('1.0'), unique=False, precision=4),
+                         "1.0000e+00")
+
+            # test trimming
+            # trim of 'k' or '.' only affects non-unique mode, since unique
+            # mode will not output trailing 0s.
+            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='k'),
+                         "1.0000")
+
+            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='.'),
+                         "1.")
+            assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='.'),
+                         "1.2" if tp != np.float16 else "1.2002")
+
+            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='0'),
+                         "1.0")
+            assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='0'),
+                         "1.2" if tp != np.float16 else "1.2002")
+            assert_equal(fpos(tp('1.'), trim='0'), "1.0")
+
+            assert_equal(fpos(tp('1.'), unique=False, precision=4, trim='-'),
+                         "1")
+            assert_equal(fpos(tp('1.2'), unique=False, precision=4, trim='-'),
+                         "1.2" if tp != np.float16 else "1.2002")
+            assert_equal(fpos(tp('1.'), trim='-'), "1")
+            assert_equal(fpos(tp('1.001'), precision=1, trim='-'), "1")
+
+    @pytest.mark.skipif(not platform.machine().startswith("ppc64"),
+                        reason="only applies to ppc float128 values")
+    def test_ppc64_ibm_double_double128(self):
+        # check that the precision decreases once we get into the subnormal
+        # range. Unlike float64, this starts around 1e-292 instead of 1e-308,
+        # which happens when the first double is normal and the second is
+        # subnormal.
+        x = np.float128('2.123123123123123123123123123123123e-286')
+        got = [str(x/np.float128('2e' + str(i))) for i in range(0,40)]
+        expected = [
+            "1.06156156156156156156156156156157e-286",
+            "1.06156156156156156156156156156158e-287",
+            "1.06156156156156156156156156156159e-288",
+            "1.0615615615615615615615615615616e-289",
+            "1.06156156156156156156156156156157e-290",
+            "1.06156156156156156156156156156156e-291",
+            "1.0615615615615615615615615615616e-292",
+            "1.0615615615615615615615615615615e-293",
+            "1.061561561561561561561561561562e-294",
+            "1.06156156156156156156156156155e-295",
+            "1.0615615615615615615615615616e-296",
+            "1.06156156156156156156156156e-297",
+            "1.06156156156156156156156157e-298",
+            "1.0615615615615615615615616e-299",
+            "1.06156156156156156156156e-300",
+            "1.06156156156156156156155e-301",
+            "1.0615615615615615615616e-302",
+            "1.061561561561561561562e-303",
+            "1.06156156156156156156e-304",
+            "1.0615615615615615618e-305",
+            "1.06156156156156156e-306",
+            "1.06156156156156157e-307",
+            "1.0615615615615616e-308",
+            "1.06156156156156e-309",
+            "1.06156156156157e-310",
+            "1.0615615615616e-311",
+            "1.06156156156e-312",
+            "1.06156156154e-313",
+            "1.0615615616e-314",
+            "1.06156156e-315",
+            "1.06156155e-316",
+            "1.061562e-317",
+            "1.06156e-318",
+            "1.06155e-319",
+            "1.0617e-320",
+            "1.06e-321",
+            "1.04e-322",
+            "1e-323",
+            "0.0",
+            "0.0"]
+        assert_equal(got, expected)
+
+        # Note: we follow glibc behavior, but it (or gcc) might not be right.
+        # In particular we can get two values that print the same but are not
+        # equal:
+        a = np.float128('2')/np.float128('3')
+        b = np.float128(str(a))
+        assert_equal(str(a), str(b))
+        assert_(a != b)
+
+    def float32_roundtrip(self):
+        # gh-9360
+        x = np.float32(1024 - 2**-14)
+        y = np.float32(1024 - 2**-13)
+        assert_(repr(x) != repr(y))
+        assert_equal(np.float32(repr(x)), x)
+        assert_equal(np.float32(repr(y)), y)
+
+    def float64_vs_python(self):
+        # gh-2643, gh-6136, gh-6908
+        assert_equal(repr(np.float64(0.1)), repr(0.1))
+        assert_(repr(np.float64(0.20000000000000004)) != repr(0.2))

env-llmeval/lib/python3.10/site-packages/numpy/fft/__init__.py

@@ -0,0 +1,212 @@
+"""
+Discrete Fourier Transform (:mod:`numpy.fft`)
+=============================================
+
+.. currentmodule:: numpy.fft
+
+The SciPy module `scipy.fft` is a more comprehensive superset
+of ``numpy.fft``, which includes only a basic set of routines.
+
+Standard FFTs
+-------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fft       Discrete Fourier transform.
+   ifft      Inverse discrete Fourier transform.
+   fft2      Discrete Fourier transform in two dimensions.
+   ifft2     Inverse discrete Fourier transform in two dimensions.
+   fftn      Discrete Fourier transform in N-dimensions.
+   ifftn     Inverse discrete Fourier transform in N dimensions.
+
+Real FFTs
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   rfft      Real discrete Fourier transform.
+   irfft     Inverse real discrete Fourier transform.
+   rfft2     Real discrete Fourier transform in two dimensions.
+   irfft2    Inverse real discrete Fourier transform in two dimensions.
+   rfftn     Real discrete Fourier transform in N dimensions.
+   irfftn    Inverse real discrete Fourier transform in N dimensions.
+
+Hermitian FFTs
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   hfft      Hermitian discrete Fourier transform.
+   ihfft     Inverse Hermitian discrete Fourier transform.
+
+Helper routines
+---------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fftfreq   Discrete Fourier Transform sample frequencies.
+   rfftfreq  DFT sample frequencies (for usage with rfft, irfft).
+   fftshift  Shift zero-frequency component to center of spectrum.
+   ifftshift Inverse of fftshift.
+
+
+Background information
+----------------------
+
+Fourier analysis is fundamentally a method for expressing a function as a
+sum of periodic components, and for recovering the function from those
+components.  When both the function and its Fourier transform are
+replaced with discretized counterparts, it is called the discrete Fourier
+transform (DFT).  The DFT has become a mainstay of numerical computing in
+part because of a very fast algorithm for computing it, called the Fast
+Fourier Transform (FFT), which was known to Gauss (1805) and was brought
+to light in its current form by Cooley and Tukey [CT]_.  Press et al. [NR]_
+provide an accessible introduction to Fourier analysis and its
+applications.
+
+Because the discrete Fourier transform separates its input into
+components that contribute at discrete frequencies, it has a great number
+of applications in digital signal processing, e.g., for filtering, and in
+this context the discretized input to the transform is customarily
+referred to as a *signal*, which exists in the *time domain*.  The output
+is called a *spectrum* or *transform* and exists in the *frequency
+domain*.
+
+Implementation details
+----------------------
+
+There are many ways to define the DFT, varying in the sign of the
+exponent, normalization, etc.  In this implementation, the DFT is defined
+as
+
+.. math::
+   A_k =  \\sum_{m=0}^{n-1} a_m \\exp\\left\\{-2\\pi i{mk \\over n}\\right\\}
+   \\qquad k = 0,\\ldots,n-1.
+
+The DFT is in general defined for complex inputs and outputs, and a
+single-frequency component at linear frequency :math:`f` is
+represented by a complex exponential
+:math:`a_m = \\exp\\{2\\pi i\\,f m\\Delta t\\}`, where :math:`\\Delta t`
+is the sampling interval.
+
+The values in the result follow so-called "standard" order: If ``A =
+fft(a, n)``, then ``A[0]`` contains the zero-frequency term (the sum of
+the signal), which is always purely real for real inputs. Then ``A[1:n/2]``
+contains the positive-frequency terms, and ``A[n/2+1:]`` contains the
+negative-frequency terms, in order of decreasingly negative frequency.
+For an even number of input points, ``A[n/2]`` represents both positive and
+negative Nyquist frequency, and is also purely real for real input.  For
+an odd number of input points, ``A[(n-1)/2]`` contains the largest positive
+frequency, while ``A[(n+1)/2]`` contains the largest negative frequency.
+The routine ``np.fft.fftfreq(n)`` returns an array giving the frequencies
+of corresponding elements in the output.  The routine
+``np.fft.fftshift(A)`` shifts transforms and their frequencies to put the
+zero-frequency components in the middle, and ``np.fft.ifftshift(A)`` undoes
+that shift.
+
+When the input `a` is a time-domain signal and ``A = fft(a)``, ``np.abs(A)``
+is its amplitude spectrum and ``np.abs(A)**2`` is its power spectrum.
+The phase spectrum is obtained by ``np.angle(A)``.
+
+The inverse DFT is defined as
+
+.. math::
+   a_m = \\frac{1}{n}\\sum_{k=0}^{n-1}A_k\\exp\\left\\{2\\pi i{mk\\over n}\\right\\}
+   \\qquad m = 0,\\ldots,n-1.
+
+It differs from the forward transform by the sign of the exponential
+argument and the default normalization by :math:`1/n`.
+
+Type Promotion
+--------------
+
+`numpy.fft` promotes ``float32`` and ``complex64`` arrays to ``float64`` and
+``complex128`` arrays respectively. For an FFT implementation that does not
+promote input arrays, see `scipy.fftpack`.
+
+Normalization
+-------------
+
+The argument ``norm`` indicates which direction of the pair of direct/inverse
+transforms is scaled and with what normalization factor.
+The default normalization (``"backward"``) has the direct (forward) transforms
+unscaled and the inverse (backward) transforms scaled by :math:`1/n`. It is
+possible to obtain unitary transforms by setting the keyword argument ``norm``
+to ``"ortho"`` so that both direct and inverse transforms are scaled by
+:math:`1/\\sqrt{n}`. Finally, setting the keyword argument ``norm`` to
+``"forward"`` has the direct transforms scaled by :math:`1/n` and the inverse
+transforms unscaled (i.e. exactly opposite to the default ``"backward"``).
+`None` is an alias of the default option ``"backward"`` for backward
+compatibility.
+
+Real and Hermitian transforms
+-----------------------------
+
+When the input is purely real, its transform is Hermitian, i.e., the
+component at frequency :math:`f_k` is the complex conjugate of the
+component at frequency :math:`-f_k`, which means that for real
+inputs there is no information in the negative frequency components that
+is not already available from the positive frequency components.
+The family of `rfft` functions is
+designed to operate on real inputs, and exploits this symmetry by
+computing only the positive frequency components, up to and including the
+Nyquist frequency.  Thus, ``n`` input points produce ``n/2+1`` complex
+output points.  The inverses of this family assumes the same symmetry of
+its input, and for an output of ``n`` points uses ``n/2+1`` input points.
+
+Correspondingly, when the spectrum is purely real, the signal is
+Hermitian.  The `hfft` family of functions exploits this symmetry by
+using ``n/2+1`` complex points in the input (time) domain for ``n`` real
+points in the frequency domain.
+
+In higher dimensions, FFTs are used, e.g., for image analysis and
+filtering.  The computational efficiency of the FFT means that it can
+also be a faster way to compute large convolutions, using the property
+that a convolution in the time domain is equivalent to a point-by-point
+multiplication in the frequency domain.
+
+Higher dimensions
+-----------------
+
+In two dimensions, the DFT is defined as
+
+.. math::
+   A_{kl} =  \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1}
+   a_{mn}\\exp\\left\\{-2\\pi i \\left({mk\\over M}+{nl\\over N}\\right)\\right\\}
+   \\qquad k = 0, \\ldots, M-1;\\quad l = 0, \\ldots, N-1,
+
+which extends in the obvious way to higher dimensions, and the inverses
+in higher dimensions also extend in the same way.
+
+References
+----------
+
+.. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
+        machine calculation of complex Fourier series," *Math. Comput.*
+        19: 297-301.
+
+.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,
+        2007, *Numerical Recipes: The Art of Scientific Computing*, ch.
+        12-13.  Cambridge Univ. Press, Cambridge, UK.
+
+Examples
+--------
+
+For examples, see the various functions.
+
+"""
+
+from . import _pocketfft, helper
+from ._pocketfft import *
+from .helper import *
+
+__all__ = _pocketfft.__all__.copy()
+__all__ += helper.__all__
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester

env-llmeval/lib/python3.10/site-packages/numpy/fft/__init__.pyi

@@ -0,0 +1,29 @@
+from numpy._pytesttester import PytestTester
+
+from numpy.fft._pocketfft import (
+    fft as fft,
+    ifft as ifft,
+    rfft as rfft,
+    irfft as irfft,
+    hfft as hfft,
+    ihfft as ihfft,
+    rfftn as rfftn,
+    irfftn as irfftn,
+    rfft2 as rfft2,
+    irfft2 as irfft2,
+    fft2 as fft2,
+    ifft2 as ifft2,
+    fftn as fftn,
+    ifftn as ifftn,
+)
+
+from numpy.fft.helper import (
+    fftshift as fftshift,
+    ifftshift as ifftshift,
+    fftfreq as fftfreq,
+    rfftfreq as rfftfreq,
+)
+
+__all__: list[str]
+__path__: list[str]
+test: PytestTester

env-llmeval/lib/python3.10/site-packages/numpy/fft/_pocketfft.py

@@ -0,0 +1,1424 @@
+"""
+Discrete Fourier Transforms
+
+Routines in this module:
+
+fft(a, n=None, axis=-1, norm="backward")
+ifft(a, n=None, axis=-1, norm="backward")
+rfft(a, n=None, axis=-1, norm="backward")
+irfft(a, n=None, axis=-1, norm="backward")
+hfft(a, n=None, axis=-1, norm="backward")
+ihfft(a, n=None, axis=-1, norm="backward")
+fftn(a, s=None, axes=None, norm="backward")
+ifftn(a, s=None, axes=None, norm="backward")
+rfftn(a, s=None, axes=None, norm="backward")
+irfftn(a, s=None, axes=None, norm="backward")
+fft2(a, s=None, axes=(-2,-1), norm="backward")
+ifft2(a, s=None, axes=(-2, -1), norm="backward")
+rfft2(a, s=None, axes=(-2,-1), norm="backward")
+irfft2(a, s=None, axes=(-2, -1), norm="backward")
+
+i = inverse transform
+r = transform of purely real data
+h = Hermite transform
+n = n-dimensional transform
+2 = 2-dimensional transform
+(Note: 2D routines are just nD routines with different default
+behavior.)
+
+"""
+__all__ = ['fft', 'ifft', 'rfft', 'irfft', 'hfft', 'ihfft', 'rfftn',
+           'irfftn', 'rfft2', 'irfft2', 'fft2', 'ifft2', 'fftn', 'ifftn']
+
+import functools
+
+from numpy.core import asarray, zeros, swapaxes, conjugate, take, sqrt
+from . import _pocketfft_internal as pfi
+from numpy.core.multiarray import normalize_axis_index
+from numpy.core import overrides
+
+
+array_function_dispatch = functools.partial(
+    overrides.array_function_dispatch, module='numpy.fft')
+
+
+# `inv_norm` is a float by which the result of the transform needs to be
+# divided. This replaces the original, more intuitive 'fct` parameter to avoid
+# divisions by zero (or alternatively additional checks) in the case of
+# zero-length axes during its computation.
+def _raw_fft(a, n, axis, is_real, is_forward, inv_norm):
+    axis = normalize_axis_index(axis, a.ndim)
+    if n is None:
+        n = a.shape[axis]
+
+    fct = 1/inv_norm
+
+    if a.shape[axis] != n:
+        s = list(a.shape)
+        index = [slice(None)]*len(s)
+        if s[axis] > n:
+            index[axis] = slice(0, n)
+            a = a[tuple(index)]
+        else:
+            index[axis] = slice(0, s[axis])
+            s[axis] = n
+            z = zeros(s, a.dtype.char)
+            z[tuple(index)] = a
+            a = z
+
+    if axis == a.ndim-1:
+        r = pfi.execute(a, is_real, is_forward, fct)
+    else:
+        a = swapaxes(a, axis, -1)
+        r = pfi.execute(a, is_real, is_forward, fct)
+        r = swapaxes(r, axis, -1)
+    return r
+
+
+def _get_forward_norm(n, norm):
+    if n < 1:
+        raise ValueError(f"Invalid number of FFT data points ({n}) specified.")
+
+    if norm is None or norm == "backward":
+        return 1
+    elif norm == "ortho":
+        return sqrt(n)
+    elif norm == "forward":
+        return n
+    raise ValueError(f'Invalid norm value {norm}; should be "backward",'
+                     '"ortho" or "forward".')
+
+
+def _get_backward_norm(n, norm):
+    if n < 1:
+        raise ValueError(f"Invalid number of FFT data points ({n}) specified.")
+
+    if norm is None or norm == "backward":
+        return n
+    elif norm == "ortho":
+        return sqrt(n)
+    elif norm == "forward":
+        return 1
+    raise ValueError(f'Invalid norm value {norm}; should be "backward", '
+                     '"ortho" or "forward".')
+
+
+_SWAP_DIRECTION_MAP = {"backward": "forward", None: "forward",
+                       "ortho": "ortho", "forward": "backward"}
+
+
+def _swap_direction(norm):
+    try:
+        return _SWAP_DIRECTION_MAP[norm]
+    except KeyError:
+        raise ValueError(f'Invalid norm value {norm}; should be "backward", '
+                         '"ortho" or "forward".') from None
+
+
+def _fft_dispatcher(a, n=None, axis=None, norm=None):
+    return (a,)
+
+
+@array_function_dispatch(_fft_dispatcher)
+def fft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the one-dimensional discrete Fourier Transform.
+
+    This function computes the one-dimensional *n*-point discrete Fourier
+    Transform (DFT) with the efficient Fast Fourier Transform (FFT)
+    algorithm [CT].
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    n : int, optional
+        Length of the transformed axis of the output.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros.  If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the FFT.  If not given, the last axis is
+        used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : for definition of the DFT and conventions used.
+    ifft : The inverse of `fft`.
+    fft2 : The two-dimensional FFT.
+    fftn : The *n*-dimensional FFT.
+    rfftn : The *n*-dimensional FFT of real input.
+    fftfreq : Frequency bins for given FFT parameters.
+
+    Notes
+    -----
+    FFT (Fast Fourier Transform) refers to a way the discrete Fourier
+    Transform (DFT) can be calculated efficiently, by using symmetries in the
+    calculated terms.  The symmetry is highest when `n` is a power of 2, and
+    the transform is therefore most efficient for these sizes.
+
+    The DFT is defined, with the conventions used in this implementation, in
+    the documentation for the `numpy.fft` module.
+
+    References
+    ----------
+    .. [CT] Cooley, James W., and John W. Tukey, 1965, "An algorithm for the
+            machine calculation of complex Fourier series," *Math. Comput.*
+            19: 297-301.
+
+    Examples
+    --------
+    >>> np.fft.fft(np.exp(2j * np.pi * np.arange(8) / 8))
+    array([-2.33486982e-16+1.14423775e-17j,  8.00000000e+00-1.25557246e-15j,
+            2.33486982e-16+2.33486982e-16j,  0.00000000e+00+1.22464680e-16j,
+           -1.14423775e-17+2.33486982e-16j,  0.00000000e+00+5.20784380e-16j,
+            1.14423775e-17+1.14423775e-17j,  0.00000000e+00+1.22464680e-16j])
+
+    In this example, real input has an FFT which is Hermitian, i.e., symmetric
+    in the real part and anti-symmetric in the imaginary part, as described in
+    the `numpy.fft` documentation:
+
+    >>> import matplotlib.pyplot as plt
+    >>> t = np.arange(256)
+    >>> sp = np.fft.fft(np.sin(t))
+    >>> freq = np.fft.fftfreq(t.shape[-1])
+    >>> plt.plot(freq, sp.real, freq, sp.imag)
+    [<matplotlib.lines.Line2D object at 0x...>, <matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.show()
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    inv_norm = _get_forward_norm(n, norm)
+    output = _raw_fft(a, n, axis, False, True, inv_norm)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def ifft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the one-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the one-dimensional *n*-point
+    discrete Fourier transform computed by `fft`.  In other words,
+    ``ifft(fft(a)) == a`` to within numerical accuracy.
+    For a general description of the algorithm and definitions,
+    see `numpy.fft`.
+
+    The input should be ordered in the same way as is returned by `fft`,
+    i.e.,
+
+    * ``a[0]`` should contain the zero frequency term,
+    * ``a[1:n//2]`` should contain the positive-frequency terms,
+    * ``a[n//2 + 1:]`` should contain the negative-frequency terms, in
+      increasing order starting from the most negative frequency.
+
+    For an even number of input points, ``A[n//2]`` represents the sum of
+    the values at the positive and negative Nyquist frequencies, as the two
+    are aliased together. See `numpy.fft` for details.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    n : int, optional
+        Length of the transformed axis of the output.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros.  If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+        See notes about padding issues.
+    axis : int, optional
+        Axis over which to compute the inverse DFT.  If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : An introduction, with definitions and general explanations.
+    fft : The one-dimensional (forward) FFT, of which `ifft` is the inverse
+    ifft2 : The two-dimensional inverse FFT.
+    ifftn : The n-dimensional inverse FFT.
+
+    Notes
+    -----
+    If the input parameter `n` is larger than the size of the input, the input
+    is padded by appending zeros at the end.  Even though this is the common
+    approach, it might lead to surprising results.  If a different padding is
+    desired, it must be performed before calling `ifft`.
+
+    Examples
+    --------
+    >>> np.fft.ifft([0, 4, 0, 0])
+    array([ 1.+0.j,  0.+1.j, -1.+0.j,  0.-1.j]) # may vary
+
+    Create and plot a band-limited signal with random phases:
+
+    >>> import matplotlib.pyplot as plt
+    >>> t = np.arange(400)
+    >>> n = np.zeros((400,), dtype=complex)
+    >>> n[40:60] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20,)))
+    >>> s = np.fft.ifft(n)
+    >>> plt.plot(t, s.real, label='real')
+    [<matplotlib.lines.Line2D object at ...>]
+    >>> plt.plot(t, s.imag, '--', label='imaginary')
+    [<matplotlib.lines.Line2D object at ...>]
+    >>> plt.legend()
+    <matplotlib.legend.Legend object at ...>
+    >>> plt.show()
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    inv_norm = _get_backward_norm(n, norm)
+    output = _raw_fft(a, n, axis, False, False, inv_norm)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def rfft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the one-dimensional discrete Fourier Transform for real input.
+
+    This function computes the one-dimensional *n*-point discrete Fourier
+    Transform (DFT) of a real-valued array by means of an efficient algorithm
+    called the Fast Fourier Transform (FFT).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    n : int, optional
+        Number of points along transformation axis in the input to use.
+        If `n` is smaller than the length of the input, the input is cropped.
+        If it is larger, the input is padded with zeros. If `n` is not given,
+        the length of the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last axis is
+        used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        If `n` is even, the length of the transformed axis is ``(n/2)+1``.
+        If `n` is odd, the length is ``(n+1)/2``.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : For definition of the DFT and conventions used.
+    irfft : The inverse of `rfft`.
+    fft : The one-dimensional FFT of general (complex) input.
+    fftn : The *n*-dimensional FFT.
+    rfftn : The *n*-dimensional FFT of real input.
+
+    Notes
+    -----
+    When the DFT is computed for purely real input, the output is
+    Hermitian-symmetric, i.e. the negative frequency terms are just the complex
+    conjugates of the corresponding positive-frequency terms, and the
+    negative-frequency terms are therefore redundant.  This function does not
+    compute the negative frequency terms, and the length of the transformed
+    axis of the output is therefore ``n//2 + 1``.
+
+    When ``A = rfft(a)`` and fs is the sampling frequency, ``A[0]`` contains
+    the zero-frequency term 0*fs, which is real due to Hermitian symmetry.
+
+    If `n` is even, ``A[-1]`` contains the term representing both positive
+    and negative Nyquist frequency (+fs/2 and -fs/2), and must also be purely
+    real. If `n` is odd, there is no term at fs/2; ``A[-1]`` contains
+    the largest positive frequency (fs/2*(n-1)/n), and is complex in the
+    general case.
+
+    If the input `a` contains an imaginary part, it is silently discarded.
+
+    Examples
+    --------
+    >>> np.fft.fft([0, 1, 0, 0])
+    array([ 1.+0.j,  0.-1.j, -1.+0.j,  0.+1.j]) # may vary
+    >>> np.fft.rfft([0, 1, 0, 0])
+    array([ 1.+0.j,  0.-1.j, -1.+0.j]) # may vary
+
+    Notice how the final element of the `fft` output is the complex conjugate
+    of the second element, for real input. For `rfft`, this symmetry is
+    exploited to compute only the non-negative frequency terms.
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    inv_norm = _get_forward_norm(n, norm)
+    output = _raw_fft(a, n, axis, True, True, inv_norm)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def irfft(a, n=None, axis=-1, norm=None):
+    """
+    Computes the inverse of `rfft`.
+
+    This function computes the inverse of the one-dimensional *n*-point
+    discrete Fourier Transform of real input computed by `rfft`.
+    In other words, ``irfft(rfft(a), len(a)) == a`` to within numerical
+    accuracy. (See Notes below for why ``len(a)`` is necessary here.)
+
+    The input is expected to be in the form returned by `rfft`, i.e. the
+    real zero-frequency term followed by the complex positive frequency terms
+    in order of increasing frequency.  Since the discrete Fourier Transform of
+    real input is Hermitian-symmetric, the negative frequency terms are taken
+    to be the complex conjugates of the corresponding positive frequency terms.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    n : int, optional
+        Length of the transformed axis of the output.
+        For `n` output points, ``n//2+1`` input points are necessary.  If the
+        input is longer than this, it is cropped.  If it is shorter than this,
+        it is padded with zeros.  If `n` is not given, it is taken to be
+        ``2*(m-1)`` where ``m`` is the length of the input along the axis
+        specified by `axis`.
+    axis : int, optional
+        Axis over which to compute the inverse FFT. If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is `n`, or, if `n` is not given,
+        ``2*(m-1)`` where ``m`` is the length of the transformed axis of the
+        input. To get an odd number of output points, `n` must be specified.
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See Also
+    --------
+    numpy.fft : For definition of the DFT and conventions used.
+    rfft : The one-dimensional FFT of real input, of which `irfft` is inverse.
+    fft : The one-dimensional FFT.
+    irfft2 : The inverse of the two-dimensional FFT of real input.
+    irfftn : The inverse of the *n*-dimensional FFT of real input.
+
+    Notes
+    -----
+    Returns the real valued `n`-point inverse discrete Fourier transform
+    of `a`, where `a` contains the non-negative frequency terms of a
+    Hermitian-symmetric sequence. `n` is the length of the result, not the
+    input.
+
+    If you specify an `n` such that `a` must be zero-padded or truncated, the
+    extra/removed values will be added/removed at high frequencies. One can
+    thus resample a series to `m` points via Fourier interpolation by:
+    ``a_resamp = irfft(rfft(a), m)``.
+
+    The correct interpretation of the hermitian input depends on the length of
+    the original data, as given by `n`. This is because each input shape could
+    correspond to either an odd or even length signal. By default, `irfft`
+    assumes an even output length which puts the last entry at the Nyquist
+    frequency; aliasing with its symmetric counterpart. By Hermitian symmetry,
+    the value is thus treated as purely real. To avoid losing information, the
+    correct length of the real input **must** be given.
+
+    Examples
+    --------
+    >>> np.fft.ifft([1, -1j, -1, 1j])
+    array([0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]) # may vary
+    >>> np.fft.irfft([1, -1j, -1])
+    array([0.,  1.,  0.,  0.])
+
+    Notice how the last term in the input to the ordinary `ifft` is the
+    complex conjugate of the second term, and the output has zero imaginary
+    part everywhere.  When calling `irfft`, the negative frequencies are not
+    specified, and the output array is purely real.
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = (a.shape[axis] - 1) * 2
+    inv_norm = _get_backward_norm(n, norm)
+    output = _raw_fft(a, n, axis, True, False, inv_norm)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def hfft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the FFT of a signal that has Hermitian symmetry, i.e., a real
+    spectrum.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    n : int, optional
+        Length of the transformed axis of the output. For `n` output
+        points, ``n//2 + 1`` input points are necessary.  If the input is
+        longer than this, it is cropped.  If it is shorter than this, it is
+        padded with zeros.  If `n` is not given, it is taken to be ``2*(m-1)``
+        where ``m`` is the length of the input along the axis specified by
+        `axis`.
+    axis : int, optional
+        Axis over which to compute the FFT. If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is `n`, or, if `n` is not given,
+        ``2*m - 2`` where ``m`` is the length of the transformed axis of
+        the input. To get an odd number of output points, `n` must be
+        specified, for instance as ``2*m - 1`` in the typical case,
+
+    Raises
+    ------
+    IndexError
+        If `axis` is not a valid axis of `a`.
+
+    See also
+    --------
+    rfft : Compute the one-dimensional FFT for real input.
+    ihfft : The inverse of `hfft`.
+
+    Notes
+    -----
+    `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
+    opposite case: here the signal has Hermitian symmetry in the time
+    domain and is real in the frequency domain. So here it's `hfft` for
+    which you must supply the length of the result if it is to be odd.
+
+    * even: ``ihfft(hfft(a, 2*len(a) - 2)) == a``, within roundoff error,
+    * odd: ``ihfft(hfft(a, 2*len(a) - 1)) == a``, within roundoff error.
+
+    The correct interpretation of the hermitian input depends on the length of
+    the original data, as given by `n`. This is because each input shape could
+    correspond to either an odd or even length signal. By default, `hfft`
+    assumes an even output length which puts the last entry at the Nyquist
+    frequency; aliasing with its symmetric counterpart. By Hermitian symmetry,
+    the value is thus treated as purely real. To avoid losing information, the
+    shape of the full signal **must** be given.
+
+    Examples
+    --------
+    >>> signal = np.array([1, 2, 3, 4, 3, 2])
+    >>> np.fft.fft(signal)
+    array([15.+0.j,  -4.+0.j,   0.+0.j,  -1.-0.j,   0.+0.j,  -4.+0.j]) # may vary
+    >>> np.fft.hfft(signal[:4]) # Input first half of signal
+    array([15.,  -4.,   0.,  -1.,   0.,  -4.])
+    >>> np.fft.hfft(signal, 6)  # Input entire signal and truncate
+    array([15.,  -4.,   0.,  -1.,   0.,  -4.])
+
+
+    >>> signal = np.array([[1, 1.j], [-1.j, 2]])
+    >>> np.conj(signal.T) - signal   # check Hermitian symmetry
+    array([[ 0.-0.j,  -0.+0.j], # may vary
+           [ 0.+0.j,  0.-0.j]])
+    >>> freq_spectrum = np.fft.hfft(signal)
+    >>> freq_spectrum
+    array([[ 1.,  1.],
+           [ 2., -2.]])
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = (a.shape[axis] - 1) * 2
+    new_norm = _swap_direction(norm)
+    output = irfft(conjugate(a), n, axis, norm=new_norm)
+    return output
+
+
+@array_function_dispatch(_fft_dispatcher)
+def ihfft(a, n=None, axis=-1, norm=None):
+    """
+    Compute the inverse FFT of a signal that has Hermitian symmetry.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    n : int, optional
+        Length of the inverse FFT, the number of points along
+        transformation axis in the input to use.  If `n` is smaller than
+        the length of the input, the input is cropped.  If it is larger,
+        the input is padded with zeros. If `n` is not given, the length of
+        the input along the axis specified by `axis` is used.
+    axis : int, optional
+        Axis over which to compute the inverse FFT. If not given, the last
+        axis is used.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axis
+        indicated by `axis`, or the last one if `axis` is not specified.
+        The length of the transformed axis is ``n//2 + 1``.
+
+    See also
+    --------
+    hfft, irfft
+
+    Notes
+    -----
+    `hfft`/`ihfft` are a pair analogous to `rfft`/`irfft`, but for the
+    opposite case: here the signal has Hermitian symmetry in the time
+    domain and is real in the frequency domain. So here it's `hfft` for
+    which you must supply the length of the result if it is to be odd:
+
+    * even: ``ihfft(hfft(a, 2*len(a) - 2)) == a``, within roundoff error,
+    * odd: ``ihfft(hfft(a, 2*len(a) - 1)) == a``, within roundoff error.
+
+    Examples
+    --------
+    >>> spectrum = np.array([ 15, -4, 0, -1, 0, -4])
+    >>> np.fft.ifft(spectrum)
+    array([1.+0.j,  2.+0.j,  3.+0.j,  4.+0.j,  3.+0.j,  2.+0.j]) # may vary
+    >>> np.fft.ihfft(spectrum)
+    array([ 1.-0.j,  2.-0.j,  3.-0.j,  4.-0.j]) # may vary
+
+    """
+    a = asarray(a)
+    if n is None:
+        n = a.shape[axis]
+    new_norm = _swap_direction(norm)
+    output = conjugate(rfft(a, n, axis, norm=new_norm))
+    return output
+
+
+def _cook_nd_args(a, s=None, axes=None, invreal=0):
+    if s is None:
+        shapeless = 1
+        if axes is None:
+            s = list(a.shape)
+        else:
+            s = take(a.shape, axes)
+    else:
+        shapeless = 0
+    s = list(s)
+    if axes is None:
+        axes = list(range(-len(s), 0))
+    if len(s) != len(axes):
+        raise ValueError("Shape and axes have different lengths.")
+    if invreal and shapeless:
+        s[-1] = (a.shape[axes[-1]] - 1) * 2
+    return s, axes
+
+
+def _raw_fftnd(a, s=None, axes=None, function=fft, norm=None):
+    a = asarray(a)
+    s, axes = _cook_nd_args(a, s, axes)
+    itl = list(range(len(axes)))
+    itl.reverse()
+    for ii in itl:
+        a = function(a, n=s[ii], axis=axes[ii], norm=norm)
+    return a
+
+
+def _fftn_dispatcher(a, s=None, axes=None, norm=None):
+    return (a,)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def fftn(a, s=None, axes=None, norm=None):
+    """
+    Compute the N-dimensional discrete Fourier Transform.
+
+    This function computes the *N*-dimensional discrete Fourier Transform over
+    any number of axes in an *M*-dimensional array by means of the Fast Fourier
+    Transform (FFT).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``fft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the transform over that axis is
+        performed multiple times.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` and `a`,
+        as explained in the parameters section above.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+        and conventions used.
+    ifftn : The inverse of `fftn`, the inverse *n*-dimensional FFT.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    rfftn : The *n*-dimensional FFT of real input.
+    fft2 : The two-dimensional FFT.
+    fftshift : Shifts zero-frequency terms to centre of array
+
+    Notes
+    -----
+    The output, analogously to `fft`, contains the term for zero frequency in
+    the low-order corner of all axes, the positive frequency terms in the
+    first half of all axes, the term for the Nyquist frequency in the middle
+    of all axes and the negative frequency terms in the second half of all
+    axes, in order of decreasingly negative frequency.
+
+    See `numpy.fft` for details, definitions and conventions used.
+
+    Examples
+    --------
+    >>> a = np.mgrid[:3, :3, :3][0]
+    >>> np.fft.fftn(a, axes=(1, 2))
+    array([[[ 0.+0.j,   0.+0.j,   0.+0.j], # may vary
+            [ 0.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j]],
+           [[ 9.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j]],
+           [[18.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j],
+            [ 0.+0.j,   0.+0.j,   0.+0.j]]])
+    >>> np.fft.fftn(a, (2, 2), axes=(0, 1))
+    array([[[ 2.+0.j,  2.+0.j,  2.+0.j], # may vary
+            [ 0.+0.j,  0.+0.j,  0.+0.j]],
+           [[-2.+0.j, -2.+0.j, -2.+0.j],
+            [ 0.+0.j,  0.+0.j,  0.+0.j]]])
+
+    >>> import matplotlib.pyplot as plt
+    >>> [X, Y] = np.meshgrid(2 * np.pi * np.arange(200) / 12,
+    ...                      2 * np.pi * np.arange(200) / 34)
+    >>> S = np.sin(X) + np.cos(Y) + np.random.uniform(0, 1, X.shape)
+    >>> FS = np.fft.fftn(S)
+    >>> plt.imshow(np.log(np.abs(np.fft.fftshift(FS))**2))
+    <matplotlib.image.AxesImage object at 0x...>
+    >>> plt.show()
+
+    """
+    return _raw_fftnd(a, s, axes, fft, norm)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def ifftn(a, s=None, axes=None, norm=None):
+    """
+    Compute the N-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the N-dimensional discrete
+    Fourier Transform over any number of axes in an M-dimensional array by
+    means of the Fast Fourier Transform (FFT).  In other words,
+    ``ifftn(fftn(a)) == a`` to within numerical accuracy.
+    For a description of the definitions and conventions used, see `numpy.fft`.
+
+    The input, analogously to `ifft`, should be ordered in the same way as is
+    returned by `fftn`, i.e. it should have the term for zero frequency
+    in all axes in the low-order corner, the positive frequency terms in the
+    first half of all axes, the term for the Nyquist frequency in the middle
+    of all axes and the negative frequency terms in the second half of all
+    axes, in order of decreasingly negative frequency.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``ifft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.  See notes for issue on `ifft` zero padding.
+    axes : sequence of ints, optional
+        Axes over which to compute the IFFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the inverse transform over that
+        axis is performed multiple times.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` or `a`,
+        as explained in the parameters section above.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    fftn : The forward *n*-dimensional FFT, of which `ifftn` is the inverse.
+    ifft : The one-dimensional inverse FFT.
+    ifft2 : The two-dimensional inverse FFT.
+    ifftshift : Undoes `fftshift`, shifts zero-frequency terms to beginning
+        of array.
+
+    Notes
+    -----
+    See `numpy.fft` for definitions and conventions used.
+
+    Zero-padding, analogously with `ifft`, is performed by appending zeros to
+    the input along the specified dimension.  Although this is the common
+    approach, it might lead to surprising results.  If another form of zero
+    padding is desired, it must be performed before `ifftn` is called.
+
+    Examples
+    --------
+    >>> a = np.eye(4)
+    >>> np.fft.ifftn(np.fft.fftn(a, axes=(0,)), axes=(1,))
+    array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
+           [0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],
+           [0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
+           [0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j]])
+
+
+    Create and plot an image with band-limited frequency content:
+
+    >>> import matplotlib.pyplot as plt
+    >>> n = np.zeros((200,200), dtype=complex)
+    >>> n[60:80, 20:40] = np.exp(1j*np.random.uniform(0, 2*np.pi, (20, 20)))
+    >>> im = np.fft.ifftn(n).real
+    >>> plt.imshow(im)
+    <matplotlib.image.AxesImage object at 0x...>
+    >>> plt.show()
+
+    """
+    return _raw_fftnd(a, s, axes, ifft, norm)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def fft2(a, s=None, axes=(-2, -1), norm=None):
+    """
+    Compute the 2-dimensional discrete Fourier Transform.
+
+    This function computes the *n*-dimensional discrete Fourier Transform
+    over any axes in an *M*-dimensional array by means of the
+    Fast Fourier Transform (FFT).  By default, the transform is computed over
+    the last two axes of the input array, i.e., a 2-dimensional FFT.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        This corresponds to ``n`` for ``fft(x, n)``.
+        Along each axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last two
+        axes are used.  A repeated index in `axes` means the transform over
+        that axis is performed multiple times.  A one-element sequence means
+        that a one-dimensional FFT is performed.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or the last two axes if `axes` is not given.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length, or `axes` not given and
+        ``len(s) != 2``.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    ifft2 : The inverse two-dimensional FFT.
+    fft : The one-dimensional FFT.
+    fftn : The *n*-dimensional FFT.
+    fftshift : Shifts zero-frequency terms to the center of the array.
+        For two-dimensional input, swaps first and third quadrants, and second
+        and fourth quadrants.
+
+    Notes
+    -----
+    `fft2` is just `fftn` with a different default for `axes`.
+
+    The output, analogously to `fft`, contains the term for zero frequency in
+    the low-order corner of the transformed axes, the positive frequency terms
+    in the first half of these axes, the term for the Nyquist frequency in the
+    middle of the axes and the negative frequency terms in the second half of
+    the axes, in order of decreasingly negative frequency.
+
+    See `fftn` for details and a plotting example, and `numpy.fft` for
+    definitions and conventions used.
+
+
+    Examples
+    --------
+    >>> a = np.mgrid[:5, :5][0]
+    >>> np.fft.fft2(a)
+    array([[ 50.  +0.j        ,   0.  +0.j        ,   0.  +0.j        , # may vary
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5+17.20477401j,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 +4.0614962j ,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 -4.0614962j ,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ],
+           [-12.5-17.20477401j,   0.  +0.j        ,   0.  +0.j        ,
+              0.  +0.j        ,   0.  +0.j        ]])
+
+    """
+    return _raw_fftnd(a, s, axes, fft, norm)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def ifft2(a, s=None, axes=(-2, -1), norm=None):
+    """
+    Compute the 2-dimensional inverse discrete Fourier Transform.
+
+    This function computes the inverse of the 2-dimensional discrete Fourier
+    Transform over any number of axes in an M-dimensional array by means of
+    the Fast Fourier Transform (FFT).  In other words, ``ifft2(fft2(a)) == a``
+    to within numerical accuracy.  By default, the inverse transform is
+    computed over the last two axes of the input array.
+
+    The input, analogously to `ifft`, should be ordered in the same way as is
+    returned by `fft2`, i.e. it should have the term for zero frequency
+    in the low-order corner of the two axes, the positive frequency terms in
+    the first half of these axes, the term for the Nyquist frequency in the
+    middle of the axes and the negative frequency terms in the second half of
+    both axes, in order of decreasingly negative frequency.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, can be complex.
+    s : sequence of ints, optional
+        Shape (length of each axis) of the output (``s[0]`` refers to axis 0,
+        ``s[1]`` to axis 1, etc.).  This corresponds to `n` for ``ifft(x, n)``.
+        Along each axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.  See notes for issue on `ifft` zero padding.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last two
+        axes are used.  A repeated index in `axes` means the transform over
+        that axis is performed multiple times.  A one-element sequence means
+        that a one-dimensional FFT is performed.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or the last two axes if `axes` is not given.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length, or `axes` not given and
+        ``len(s) != 2``.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    numpy.fft : Overall view of discrete Fourier transforms, with definitions
+         and conventions used.
+    fft2 : The forward 2-dimensional FFT, of which `ifft2` is the inverse.
+    ifftn : The inverse of the *n*-dimensional FFT.
+    fft : The one-dimensional FFT.
+    ifft : The one-dimensional inverse FFT.
+
+    Notes
+    -----
+    `ifft2` is just `ifftn` with a different default for `axes`.
+
+    See `ifftn` for details and a plotting example, and `numpy.fft` for
+    definition and conventions used.
+
+    Zero-padding, analogously with `ifft`, is performed by appending zeros to
+    the input along the specified dimension.  Although this is the common
+    approach, it might lead to surprising results.  If another form of zero
+    padding is desired, it must be performed before `ifft2` is called.
+
+    Examples
+    --------
+    >>> a = 4 * np.eye(4)
+    >>> np.fft.ifft2(a)
+    array([[1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j], # may vary
+           [0.+0.j,  0.+0.j,  0.+0.j,  1.+0.j],
+           [0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],
+           [0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j]])
+
+    """
+    return _raw_fftnd(a, s, axes, ifft, norm)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def rfftn(a, s=None, axes=None, norm=None):
+    """
+    Compute the N-dimensional discrete Fourier Transform for real input.
+
+    This function computes the N-dimensional discrete Fourier Transform over
+    any number of axes in an M-dimensional real array by means of the Fast
+    Fourier Transform (FFT).  By default, all axes are transformed, with the
+    real transform performed over the last axis, while the remaining
+    transforms are complex.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, taken to be real.
+    s : sequence of ints, optional
+        Shape (length along each transformed axis) to use from the input.
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.).
+        The final element of `s` corresponds to `n` for ``rfft(x, n)``, while
+        for the remaining axes, it corresponds to `n` for ``fft(x, n)``.
+        Along any axis, if the given shape is smaller than that of the input,
+        the input is cropped.  If it is larger, the input is padded with zeros.
+        if `s` is not given, the shape of the input along the axes specified
+        by `axes` is used.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.  If not given, the last ``len(s)``
+        axes are used, or all axes if `s` is also not specified.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : complex ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` and `a`,
+        as explained in the parameters section above.
+        The length of the last axis transformed will be ``s[-1]//2+1``,
+        while the remaining transformed axes will have lengths according to
+        `s`, or unchanged from the input.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    irfftn : The inverse of `rfftn`, i.e. the inverse of the n-dimensional FFT
+         of real input.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    rfft : The one-dimensional FFT of real input.
+    fftn : The n-dimensional FFT.
+    rfft2 : The two-dimensional FFT of real input.
+
+    Notes
+    -----
+    The transform for real input is performed over the last transformation
+    axis, as by `rfft`, then the transform over the remaining axes is
+    performed as by `fftn`.  The order of the output is as for `rfft` for the
+    final transformation axis, and as for `fftn` for the remaining
+    transformation axes.
+
+    See `fft` for details, definitions and conventions used.
+
+    Examples
+    --------
+    >>> a = np.ones((2, 2, 2))
+    >>> np.fft.rfftn(a)
+    array([[[8.+0.j,  0.+0.j], # may vary
+            [0.+0.j,  0.+0.j]],
+           [[0.+0.j,  0.+0.j],
+            [0.+0.j,  0.+0.j]]])
+
+    >>> np.fft.rfftn(a, axes=(2, 0))
+    array([[[4.+0.j,  0.+0.j], # may vary
+            [4.+0.j,  0.+0.j]],
+           [[0.+0.j,  0.+0.j],
+            [0.+0.j,  0.+0.j]]])
+
+    """
+    a = asarray(a)
+    s, axes = _cook_nd_args(a, s, axes)
+    a = rfft(a, s[-1], axes[-1], norm)
+    for ii in range(len(axes)-1):
+        a = fft(a, s[ii], axes[ii], norm)
+    return a
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def rfft2(a, s=None, axes=(-2, -1), norm=None):
+    """
+    Compute the 2-dimensional FFT of a real array.
+
+    Parameters
+    ----------
+    a : array
+        Input array, taken to be real.
+    s : sequence of ints, optional
+        Shape of the FFT.
+    axes : sequence of ints, optional
+        Axes over which to compute the FFT.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : ndarray
+        The result of the real 2-D FFT.
+
+    See Also
+    --------
+    rfftn : Compute the N-dimensional discrete Fourier Transform for real
+            input.
+
+    Notes
+    -----
+    This is really just `rfftn` with different default behavior.
+    For more details see `rfftn`.
+
+    Examples
+    --------
+    >>> a = np.mgrid[:5, :5][0]
+    >>> np.fft.rfft2(a)
+    array([[ 50.  +0.j        ,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5+17.20477401j,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 +4.0614962j ,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5 -4.0614962j ,   0.  +0.j        ,   0.  +0.j        ],
+           [-12.5-17.20477401j,   0.  +0.j        ,   0.  +0.j        ]])
+    """
+    return rfftn(a, s, axes, norm)
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def irfftn(a, s=None, axes=None, norm=None):
+    """
+    Computes the inverse of `rfftn`.
+
+    This function computes the inverse of the N-dimensional discrete
+    Fourier Transform for real input over any number of axes in an
+    M-dimensional array by means of the Fast Fourier Transform (FFT).  In
+    other words, ``irfftn(rfftn(a), a.shape) == a`` to within numerical
+    accuracy. (The ``a.shape`` is necessary like ``len(a)`` is for `irfft`,
+    and for the same reason.)
+
+    The input should be ordered in the same way as is returned by `rfftn`,
+    i.e. as for `irfft` for the final transformation axis, and as for `ifftn`
+    along all the other axes.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    s : sequence of ints, optional
+        Shape (length of each transformed axis) of the output
+        (``s[0]`` refers to axis 0, ``s[1]`` to axis 1, etc.). `s` is also the
+        number of input points used along this axis, except for the last axis,
+        where ``s[-1]//2+1`` points of the input are used.
+        Along any axis, if the shape indicated by `s` is smaller than that of
+        the input, the input is cropped.  If it is larger, the input is padded
+        with zeros. If `s` is not given, the shape of the input along the axes
+        specified by axes is used. Except for the last axis which is taken to
+        be ``2*(m-1)`` where ``m`` is the length of the input along that axis.
+    axes : sequence of ints, optional
+        Axes over which to compute the inverse FFT. If not given, the last
+        `len(s)` axes are used, or all axes if `s` is also not specified.
+        Repeated indices in `axes` means that the inverse transform over that
+        axis is performed multiple times.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : ndarray
+        The truncated or zero-padded input, transformed along the axes
+        indicated by `axes`, or by a combination of `s` or `a`,
+        as explained in the parameters section above.
+        The length of each transformed axis is as given by the corresponding
+        element of `s`, or the length of the input in every axis except for the
+        last one if `s` is not given.  In the final transformed axis the length
+        of the output when `s` is not given is ``2*(m-1)`` where ``m`` is the
+        length of the final transformed axis of the input.  To get an odd
+        number of output points in the final axis, `s` must be specified.
+
+    Raises
+    ------
+    ValueError
+        If `s` and `axes` have different length.
+    IndexError
+        If an element of `axes` is larger than than the number of axes of `a`.
+
+    See Also
+    --------
+    rfftn : The forward n-dimensional FFT of real input,
+            of which `ifftn` is the inverse.
+    fft : The one-dimensional FFT, with definitions and conventions used.
+    irfft : The inverse of the one-dimensional FFT of real input.
+    irfft2 : The inverse of the two-dimensional FFT of real input.
+
+    Notes
+    -----
+    See `fft` for definitions and conventions used.
+
+    See `rfft` for definitions and conventions used for real input.
+
+    The correct interpretation of the hermitian input depends on the shape of
+    the original data, as given by `s`. This is because each input shape could
+    correspond to either an odd or even length signal. By default, `irfftn`
+    assumes an even output length which puts the last entry at the Nyquist
+    frequency; aliasing with its symmetric counterpart. When performing the
+    final complex to real transform, the last value is thus treated as purely
+    real. To avoid losing information, the correct shape of the real input
+    **must** be given.
+
+    Examples
+    --------
+    >>> a = np.zeros((3, 2, 2))
+    >>> a[0, 0, 0] = 3 * 2 * 2
+    >>> np.fft.irfftn(a)
+    array([[[1.,  1.],
+            [1.,  1.]],
+           [[1.,  1.],
+            [1.,  1.]],
+           [[1.,  1.],
+            [1.,  1.]]])
+
+    """
+    a = asarray(a)
+    s, axes = _cook_nd_args(a, s, axes, invreal=1)
+    for ii in range(len(axes)-1):
+        a = ifft(a, s[ii], axes[ii], norm)
+    a = irfft(a, s[-1], axes[-1], norm)
+    return a
+
+
+@array_function_dispatch(_fftn_dispatcher)
+def irfft2(a, s=None, axes=(-2, -1), norm=None):
+    """
+    Computes the inverse of `rfft2`.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array
+    s : sequence of ints, optional
+        Shape of the real output to the inverse FFT.
+    axes : sequence of ints, optional
+        The axes over which to compute the inverse fft.
+        Default is the last two axes.
+    norm : {"backward", "ortho", "forward"}, optional
+        .. versionadded:: 1.10.0
+
+        Normalization mode (see `numpy.fft`). Default is "backward".
+        Indicates which direction of the forward/backward pair of transforms
+        is scaled and with what normalization factor.
+
+        .. versionadded:: 1.20.0
+
+            The "backward", "forward" values were added.
+
+    Returns
+    -------
+    out : ndarray
+        The result of the inverse real 2-D FFT.
+
+    See Also
+    --------
+    rfft2 : The forward two-dimensional FFT of real input,
+            of which `irfft2` is the inverse.
+    rfft : The one-dimensional FFT for real input.
+    irfft : The inverse of the one-dimensional FFT of real input.
+    irfftn : Compute the inverse of the N-dimensional FFT of real input.
+
+    Notes
+    -----
+    This is really `irfftn` with different defaults.
+    For more details see `irfftn`.
+
+    Examples
+    --------
+    >>> a = np.mgrid[:5, :5][0]
+    >>> A = np.fft.rfft2(a)
+    >>> np.fft.irfft2(A, s=a.shape)
+    array([[0., 0., 0., 0., 0.],
+           [1., 1., 1., 1., 1.],
+           [2., 2., 2., 2., 2.],
+           [3., 3., 3., 3., 3.],
+           [4., 4., 4., 4., 4.]])
+    """
+    return irfftn(a, s, axes, norm)

env-llmeval/lib/python3.10/site-packages/numpy/fft/_pocketfft.pyi

@@ -0,0 +1,108 @@
+from collections.abc import Sequence
+from typing import Literal as L
+
+from numpy import complex128, float64
+from numpy._typing import ArrayLike, NDArray, _ArrayLikeNumber_co
+
+_NormKind = L[None, "backward", "ortho", "forward"]
+
+__all__: list[str]
+
+def fft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def ifft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def rfft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def irfft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+) -> NDArray[float64]: ...
+
+# Input array must be compatible with `np.conjugate`
+def hfft(
+    a: _ArrayLikeNumber_co,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+) -> NDArray[float64]: ...
+
+def ihfft(
+    a: ArrayLike,
+    n: None | int = ...,
+    axis: int = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def fftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def ifftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def rfftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def irfftn(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[float64]: ...
+
+def fft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def ifft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def rfft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[complex128]: ...
+
+def irfft2(
+    a: ArrayLike,
+    s: None | Sequence[int] = ...,
+    axes: None | Sequence[int] = ...,
+    norm: _NormKind = ...,
+) -> NDArray[float64]: ...

env-llmeval/lib/python3.10/site-packages/numpy/fft/helper.py

@@ -0,0 +1,221 @@
+"""
+Discrete Fourier Transforms - helper.py
+
+"""
+from numpy.core import integer, empty, arange, asarray, roll
+from numpy.core.overrides import array_function_dispatch, set_module
+
+# Created by Pearu Peterson, September 2002
+
+__all__ = ['fftshift', 'ifftshift', 'fftfreq', 'rfftfreq']
+
+integer_types = (int, integer)
+
+
+def _fftshift_dispatcher(x, axes=None):
+    return (x,)
+
+
+@array_function_dispatch(_fftshift_dispatcher, module='numpy.fft')
+def fftshift(x, axes=None):
+    """
+    Shift the zero-frequency component to the center of the spectrum.
+
+    This function swaps half-spaces for all axes listed (defaults to all).
+    Note that ``y[0]`` is the Nyquist component only if ``len(x)`` is even.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axes : int or shape tuple, optional
+        Axes over which to shift.  Default is None, which shifts all axes.
+
+    Returns
+    -------
+    y : ndarray
+        The shifted array.
+
+    See Also
+    --------
+    ifftshift : The inverse of `fftshift`.
+
+    Examples
+    --------
+    >>> freqs = np.fft.fftfreq(10, 0.1)
+    >>> freqs
+    array([ 0.,  1.,  2., ..., -3., -2., -1.])
+    >>> np.fft.fftshift(freqs)
+    array([-5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
+
+    Shift the zero-frequency component only along the second axis:
+
+    >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
+    >>> freqs
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+    >>> np.fft.fftshift(freqs, axes=(1,))
+    array([[ 2.,  0.,  1.],
+           [-4.,  3.,  4.],
+           [-1., -3., -2.]])
+
+    """
+    x = asarray(x)
+    if axes is None:
+        axes = tuple(range(x.ndim))
+        shift = [dim // 2 for dim in x.shape]
+    elif isinstance(axes, integer_types):
+        shift = x.shape[axes] // 2
+    else:
+        shift = [x.shape[ax] // 2 for ax in axes]
+
+    return roll(x, shift, axes)
+
+
+@array_function_dispatch(_fftshift_dispatcher, module='numpy.fft')
+def ifftshift(x, axes=None):
+    """
+    The inverse of `fftshift`. Although identical for even-length `x`, the
+    functions differ by one sample for odd-length `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+    axes : int or shape tuple, optional
+        Axes over which to calculate.  Defaults to None, which shifts all axes.
+
+    Returns
+    -------
+    y : ndarray
+        The shifted array.
+
+    See Also
+    --------
+    fftshift : Shift zero-frequency component to the center of the spectrum.
+
+    Examples
+    --------
+    >>> freqs = np.fft.fftfreq(9, d=1./9).reshape(3, 3)
+    >>> freqs
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+    >>> np.fft.ifftshift(np.fft.fftshift(freqs))
+    array([[ 0.,  1.,  2.],
+           [ 3.,  4., -4.],
+           [-3., -2., -1.]])
+
+    """
+    x = asarray(x)
+    if axes is None:
+        axes = tuple(range(x.ndim))
+        shift = [-(dim // 2) for dim in x.shape]
+    elif isinstance(axes, integer_types):
+        shift = -(x.shape[axes] // 2)
+    else:
+        shift = [-(x.shape[ax] // 2) for ax in axes]
+
+    return roll(x, shift, axes)
+
+
+@set_module('numpy.fft')
+def fftfreq(n, d=1.0):
+    """
+    Return the Discrete Fourier Transform sample frequencies.
+
+    The returned float array `f` contains the frequency bin centers in cycles
+    per unit of the sample spacing (with zero at the start).  For instance, if
+    the sample spacing is in seconds, then the frequency unit is cycles/second.
+
+    Given a window length `n` and a sample spacing `d`::
+
+      f = [0, 1, ...,   n/2-1,     -n/2, ..., -1] / (d*n)   if n is even
+      f = [0, 1, ..., (n-1)/2, -(n-1)/2, ..., -1] / (d*n)   if n is odd
+
+    Parameters
+    ----------
+    n : int
+        Window length.
+    d : scalar, optional
+        Sample spacing (inverse of the sampling rate). Defaults to 1.
+
+    Returns
+    -------
+    f : ndarray
+        Array of length `n` containing the sample frequencies.
+
+    Examples
+    --------
+    >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5], dtype=float)
+    >>> fourier = np.fft.fft(signal)
+    >>> n = signal.size
+    >>> timestep = 0.1
+    >>> freq = np.fft.fftfreq(n, d=timestep)
+    >>> freq
+    array([ 0.  ,  1.25,  2.5 , ..., -3.75, -2.5 , -1.25])
+
+    """
+    if not isinstance(n, integer_types):
+        raise ValueError("n should be an integer")
+    val = 1.0 / (n * d)
+    results = empty(n, int)
+    N = (n-1)//2 + 1
+    p1 = arange(0, N, dtype=int)
+    results[:N] = p1
+    p2 = arange(-(n//2), 0, dtype=int)
+    results[N:] = p2
+    return results * val
+
+
+@set_module('numpy.fft')
+def rfftfreq(n, d=1.0):
+    """
+    Return the Discrete Fourier Transform sample frequencies
+    (for usage with rfft, irfft).
+
+    The returned float array `f` contains the frequency bin centers in cycles
+    per unit of the sample spacing (with zero at the start).  For instance, if
+    the sample spacing is in seconds, then the frequency unit is cycles/second.
+
+    Given a window length `n` and a sample spacing `d`::
+
+      f = [0, 1, ...,     n/2-1,     n/2] / (d*n)   if n is even
+      f = [0, 1, ..., (n-1)/2-1, (n-1)/2] / (d*n)   if n is odd
+
+    Unlike `fftfreq` (but like `scipy.fftpack.rfftfreq`)
+    the Nyquist frequency component is considered to be positive.
+
+    Parameters
+    ----------
+    n : int
+        Window length.
+    d : scalar, optional
+        Sample spacing (inverse of the sampling rate). Defaults to 1.
+
+    Returns
+    -------
+    f : ndarray
+        Array of length ``n//2 + 1`` containing the sample frequencies.
+
+    Examples
+    --------
+    >>> signal = np.array([-2, 8, 6, 4, 1, 0, 3, 5, -3, 4], dtype=float)
+    >>> fourier = np.fft.rfft(signal)
+    >>> n = signal.size
+    >>> sample_rate = 100
+    >>> freq = np.fft.fftfreq(n, d=1./sample_rate)
+    >>> freq
+    array([  0.,  10.,  20., ..., -30., -20., -10.])
+    >>> freq = np.fft.rfftfreq(n, d=1./sample_rate)
+    >>> freq
+    array([  0.,  10.,  20.,  30.,  40.,  50.])
+
+    """
+    if not isinstance(n, integer_types):
+        raise ValueError("n should be an integer")
+    val = 1.0/(n*d)
+    N = n//2 + 1
+    results = arange(0, N, dtype=int)
+    return results * val

env-llmeval/lib/python3.10/site-packages/numpy/fft/helper.pyi

@@ -0,0 +1,47 @@
+from typing import Any, TypeVar, overload
+
+from numpy import generic, integer, floating, complexfloating
+from numpy._typing import (
+    NDArray,
+    ArrayLike,
+    _ShapeLike,
+    _ArrayLike,
+    _ArrayLikeFloat_co,
+    _ArrayLikeComplex_co,
+)
+
+_SCT = TypeVar("_SCT", bound=generic)
+
+__all__: list[str]
+
+@overload
+def fftshift(x: _ArrayLike[_SCT], axes: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
+@overload
+def fftshift(x: ArrayLike, axes: None | _ShapeLike = ...) -> NDArray[Any]: ...
+
+@overload
+def ifftshift(x: _ArrayLike[_SCT], axes: None | _ShapeLike = ...) -> NDArray[_SCT]: ...
+@overload
+def ifftshift(x: ArrayLike, axes: None | _ShapeLike = ...) -> NDArray[Any]: ...
+
+@overload
+def fftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeFloat_co = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def fftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeComplex_co = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...
+
+@overload
+def rfftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeFloat_co = ...,
+) -> NDArray[floating[Any]]: ...
+@overload
+def rfftfreq(
+    n: int | integer[Any],
+    d: _ArrayLikeComplex_co = ...,
+) -> NDArray[complexfloating[Any, Any]]: ...

env-llmeval/lib/python3.10/site-packages/numpy/ma/API_CHANGES.txt

@@ -0,0 +1,135 @@
+.. -*- rest -*-
+
+==================================================
+API changes in the new masked array implementation
+==================================================
+
+Masked arrays are subclasses of ndarray
+---------------------------------------
+
+Contrary to the original implementation, masked arrays are now regular
+ndarrays::
+
+  >>> x = masked_array([1,2,3],mask=[0,0,1])
+  >>> print isinstance(x, numpy.ndarray)
+  True
+
+
+``_data`` returns a view of the masked array
+--------------------------------------------
+
+Masked arrays are composed of a ``_data`` part and a ``_mask``. Accessing the
+``_data`` part will return a regular ndarray or any of its subclass, depending
+on the initial data::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> print x._data
+  [[1 2]
+   [3 4]]
+  >>> print type(x._data)
+  <class 'numpy.matrixlib.defmatrix.matrix'>
+
+
+In practice, ``_data`` is implemented as a property, not as an attribute.
+Therefore, you cannot access it directly, and some simple tests such as the
+following one will fail::
+
+  >>>x._data is x._data
+  False
+
+
+``filled(x)`` can return a subclass of ndarray
+----------------------------------------------
+The function ``filled(a)`` returns an array of the same type as ``a._data``::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> y = filled(x)
+  >>> print type(y)
+  <class 'numpy.matrixlib.defmatrix.matrix'>
+  >>> print y
+  matrix([[     1,      2],
+          [     3, 999999]])
+
+
+``put``, ``putmask`` behave like their ndarray counterparts
+-----------------------------------------------------------
+
+Previously, ``putmask`` was used like this::
+
+  mask = [False,True,True]
+  x = array([1,4,7],mask=mask)
+  putmask(x,mask,[3])
+
+which translated to::
+
+  x[~mask] = [3]
+
+(Note that a ``True``-value in a mask suppresses a value.)
+
+In other words, the mask had the same length as ``x``, whereas
+``values`` had ``sum(~mask)`` elements.
+
+Now, the behaviour is similar to that of ``ndarray.putmask``, where
+the mask and the values are both the same length as ``x``, i.e.
+
+::
+
+  putmask(x,mask,[3,0,0])
+
+
+``fill_value`` is a property
+----------------------------
+
+``fill_value`` is no longer a method, but a property::
+
+  >>> print x.fill_value
+  999999
+
+``cumsum`` and ``cumprod`` ignore missing values
+------------------------------------------------
+
+Missing values are assumed to be the identity element, i.e. 0 for
+``cumsum`` and 1 for ``cumprod``::
+
+  >>> x = N.ma.array([1,2,3,4],mask=[False,True,False,False])
+  >>> print x
+  [1 -- 3 4]
+  >>> print x.cumsum()
+  [1 -- 4 8]
+  >> print x.cumprod()
+  [1 -- 3 12]
+
+``bool(x)`` raises a ValueError
+-------------------------------
+
+Masked arrays now behave like regular ``ndarrays``, in that they cannot be
+converted to booleans:
+
+::
+
+  >>> x = N.ma.array([1,2,3])
+  >>> bool(x)
+  Traceback (most recent call last):
+    File "<stdin>", line 1, in <module>
+  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
+
+
+==================================
+New features (non exhaustive list)
+==================================
+
+``mr_``
+-------
+
+``mr_`` mimics the behavior of ``r_`` for masked arrays::
+
+  >>> np.ma.mr_[3,4,5]
+  masked_array(data = [3 4 5],
+        mask = False,
+        fill_value=999999)
+
+
+``anom``
+--------
+
+The ``anom`` method returns the deviations from the average (anomalies).

env-llmeval/lib/python3.10/site-packages/numpy/ma/LICENSE

@@ -0,0 +1,24 @@
+* Copyright (c) 2006, University of Georgia and Pierre G.F. Gerard-Marchant
+* 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 University of Georgia 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 REGENTS 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 REGENTS 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.

env-llmeval/lib/python3.10/site-packages/numpy/ma/README.rst

@@ -0,0 +1,236 @@
+==================================
+A Guide to Masked Arrays in NumPy
+==================================
+
+.. Contents::
+
+See http://www.scipy.org/scipy/numpy/wiki/MaskedArray (dead link)
+for updates of this document.
+
+
+History
+-------
+
+As a regular user of MaskedArray, I (Pierre G.F. Gerard-Marchant) became
+increasingly frustrated with the subclassing of masked arrays (even if
+I can only blame my inexperience). I needed to develop a class of arrays
+that could store some additional information along with numerical values,
+while keeping the possibility for missing data (picture storing a series
+of dates along with measurements, what would later become the `TimeSeries
+Scikit <http://projects.scipy.org/scipy/scikits/wiki/TimeSeries>`__
+(dead link).
+
+I started to implement such a class, but then quickly realized that
+any additional information disappeared when processing these subarrays
+(for example, adding a constant value to a subarray would erase its
+dates). I ended up writing the equivalent of *numpy.core.ma* for my
+particular class, ufuncs included. Everything went fine until I needed to
+subclass my new class, when more problems showed up: some attributes of
+the new subclass were lost during processing. I identified the culprit as
+MaskedArray, which returns masked ndarrays when I expected masked
+arrays of my class. I was preparing myself to rewrite *numpy.core.ma*
+when I forced myself to learn how to subclass ndarrays. As I became more
+familiar with the *__new__* and *__array_finalize__* methods,
+I started to wonder why masked arrays were objects, and not ndarrays,
+and whether it wouldn't be more convenient for subclassing if they did
+behave like regular ndarrays.
+
+The new *maskedarray* is what I eventually come up with. The
+main differences with the initial *numpy.core.ma* package are
+that MaskedArray is now a subclass of *ndarray* and that the
+*_data* section can now be any subclass of *ndarray*. Apart from a
+couple of issues listed below, the behavior of the new MaskedArray
+class reproduces the old one. Initially the *maskedarray*
+implementation was marginally slower than *numpy.ma* in some areas,
+but work is underway to speed it up; the expectation is that it can be
+made substantially faster than the present *numpy.ma*.
+
+
+Note that if the subclass has some special methods and
+attributes, they are not propagated to the masked version:
+this would require a modification of the *__getattribute__*
+method (first trying *ndarray.__getattribute__*, then trying
+*self._data.__getattribute__* if an exception is raised in the first
+place), which really slows things down.
+
+Main differences
+----------------
+
+ * The *_data* part of the masked array can be any subclass of ndarray (but not recarray, cf below).
+ * *fill_value* is now a property, not a function.
+ * in the majority of cases, the mask is forced to *nomask* when no value is actually masked. A notable exception is when a masked array (with no masked values) has just been unpickled.
+ * I got rid of the *share_mask* flag, I never understood its purpose.
+ * *put*, *putmask* and *take* now mimic the ndarray methods, to avoid unpleasant surprises. Moreover, *put* and *putmask* both update the mask when needed.  * if *a* is a masked array, *bool(a)* raises a *ValueError*, as it does with ndarrays.
+ * in the same way, the comparison of two masked arrays is a masked array, not a boolean
+ * *filled(a)* returns an array of the same subclass as *a._data*, and no test is performed on whether it is contiguous or not.
+ * the mask is always printed, even if it's *nomask*, which makes things easy (for me at least) to remember that a masked array is used.
+ * *cumsum* works as if the *_data* array was filled with 0. The mask is preserved, but not updated.
+ * *cumprod* works as if the *_data* array was filled with 1. The mask is preserved, but not updated.
+
+New features
+------------
+
+This list is non-exhaustive...
+
+ * the *mr_* function mimics *r_* for masked arrays.
+ * the *anom* method returns the anomalies (deviations from the average)
+
+Using the new package with numpy.core.ma
+----------------------------------------
+
+I tried to make sure that the new package can understand old masked
+arrays. Unfortunately, there's no upward compatibility.
+
+For example:
+
+>>> import numpy.core.ma as old_ma
+>>> import maskedarray as new_ma
+>>> x = old_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> x
+array(data =
+ [     1      2 999999      4      5],
+      mask =
+ [False False True False False],
+      fill_value=999999)
+>>> y = new_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> y
+array(data = [1 2 -- 4 5],
+      mask = [False False True False False],
+      fill_value=999999)
+>>> x==y
+array(data =
+ [True True True True True],
+      mask =
+ [False False True False False],
+      fill_value=?)
+>>> old_ma.getmask(x) == new_ma.getmask(x)
+array([True, True, True, True, True])
+>>> old_ma.getmask(y) == new_ma.getmask(y)
+array([True, True, False, True, True])
+>>> old_ma.getmask(y)
+False
+
+
+Using maskedarray with matplotlib
+---------------------------------
+
+Starting with matplotlib 0.91.2, the masked array importing will work with
+the maskedarray branch) as well as with earlier versions.
+
+By default matplotlib still uses numpy.ma, but there is an rcParams setting
+that you can use to select maskedarray instead.  In the matplotlibrc file
+you will find::
+
+  #maskedarray : False       # True to use external maskedarray module
+                             # instead of numpy.ma; this is a temporary #
+                             setting for testing maskedarray.
+
+
+Uncomment and set to True to select maskedarray everywhere.
+Alternatively, you can test a script with maskedarray by using a
+command-line option, e.g.::
+
+  python simple_plot.py --maskedarray
+
+
+Masked records
+--------------
+
+Like *numpy.core.ma*, the *ndarray*-based implementation
+of MaskedArray is limited when working with records: you can
+mask any record of the array, but not a field in a record. If you
+need this feature, you may want to give the *mrecords* package
+a try (available in the *maskedarray* directory in the scipy
+sandbox). This module defines a new class, *MaskedRecord*. An
+instance of this class accepts a *recarray* as data, and uses two
+masks: the *fieldmask* has as many entries as records in the array,
+each entry with the same fields as a record, but of boolean types:
+they indicate whether the field is masked or not; a record entry
+is flagged as masked in the *mask* array if all the fields are
+masked. A few examples in the file should give you an idea of what
+can be done. Note that *mrecords* is still experimental...
+
+Optimizing maskedarray
+----------------------
+
+Should masked arrays be filled before processing or not?
+--------------------------------------------------------
+
+In the current implementation, most operations on masked arrays involve
+the following steps:
+
+ * the input arrays are filled
+ * the operation is performed on the filled arrays
+ * the mask is set for the results, from the combination of the input masks and the mask corresponding to the domain of the operation.
+
+For example, consider the division of two masked arrays::
+
+  import numpy
+  import maskedarray as ma
+  x = ma.array([1,2,3,4],mask=[1,0,0,0], dtype=numpy.float_)
+  y = ma.array([-1,0,1,2], mask=[0,0,0,1], dtype=numpy.float_)
+
+The division of x by y is then computed as::
+
+  d1 = x.filled(0) # d1 = array([0., 2., 3., 4.])
+  d2 = y.filled(1) # array([-1.,  0.,  1.,  1.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  result = (d1/d2).view(MaskedArray) # masked_array([-0. inf, 3., 4.])
+  result._mask = logical_or(m, dm)
+
+Note that a division by zero takes place. To avoid it, we can consider
+to fill the input arrays, taking the domain mask into account, so that::
+
+  d1 = x._data.copy() # d1 = array([1., 2., 3., 4.])
+  d2 = y._data.copy() # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  numpy.putmask(d2, dm, 1) # d2 = array([-1.,  1.,  1.,  2.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. 0., 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that the *.copy()* is required to avoid updating the inputs with
+*putmask*.  The *.filled()* method also involves a *.copy()*.
+
+A third possibility consists in avoid filling the arrays::
+
+  d1 = x._data # d1 = array([1., 2., 3., 4.])
+  d2 = y._data # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. inf, 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that here again the division by zero takes place.
+
+A quick benchmark gives the following results:
+
+ * *numpy.ma.divide*  : 2.69 ms per loop
+ * classical division     : 2.21 ms per loop
+ * division w/ prefilling : 2.34 ms per loop
+ * division w/o filling   : 1.55 ms per loop
+
+So, is it worth filling the arrays beforehand ? Yes, if we are interested
+in avoiding floating-point exceptions that may fill the result with infs
+and nans. No, if we are only interested into speed...
+
+
+Thanks
+------
+
+I'd like to thank Paul Dubois, Travis Oliphant and Sasha for the
+original masked array package: without you, I would never have started
+that (it might be argued that I shouldn't have anyway, but that's
+another story...).  I also wish to extend these thanks to Reggie Dugard
+and Eric Firing for their suggestions and numerous improvements.
+
+
+Revision notes
+--------------
+
+  * 08/25/2007 : Creation of this page
+  * 01/23/2007 : The package has been moved to the SciPy sandbox, and is regularly updated: please check out your SVN version!

env-llmeval/lib/python3.10/site-packages/numpy/ma/__init__.py

@@ -0,0 +1,54 @@
+"""
+=============
+Masked Arrays
+=============
+
+Arrays sometimes contain invalid or missing data.  When doing operations
+on such arrays, we wish to suppress invalid values, which is the purpose masked
+arrays fulfill (an example of typical use is given below).
+
+For example, examine the following array:
+
+>>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])
+
+When we try to calculate the mean of the data, the result is undetermined:
+
+>>> np.mean(x)
+nan
+
+The mean is calculated using roughly ``np.sum(x)/len(x)``, but since
+any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work.  Enter
+masked arrays:
+
+>>> m = np.ma.masked_array(x, np.isnan(x))
+>>> m
+masked_array(data = [2.0 1.0 3.0 -- 5.0 2.0 3.0 --],
+      mask = [False False False  True False False False  True],
+      fill_value=1e+20)
+
+Here, we construct a masked array that suppress all ``NaN`` values.  We
+may now proceed to calculate the mean of the other values:
+
+>>> np.mean(m)
+2.6666666666666665
+
+.. [1] Not-a-Number, a floating point value that is the result of an
+       invalid operation.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+.. moduleauthor:: Jarrod Millman
+
+"""
+from . import core
+from .core import *
+
+from . import extras
+from .extras import *
+
+__all__ = ['core', 'extras']
+__all__ += core.__all__
+__all__ += extras.__all__
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester

env-llmeval/lib/python3.10/site-packages/numpy/ma/__init__.pyi

@@ -0,0 +1,234 @@
+from numpy._pytesttester import PytestTester
+
+from numpy.ma import extras as extras
+
+from numpy.ma.core import (
+    MAError as MAError,
+    MaskError as MaskError,
+    MaskType as MaskType,
+    MaskedArray as MaskedArray,
+    abs as abs,
+    absolute as absolute,
+    add as add,
+    all as all,
+    allclose as allclose,
+    allequal as allequal,
+    alltrue as alltrue,
+    amax as amax,
+    amin as amin,
+    angle as angle,
+    anom as anom,
+    anomalies as anomalies,
+    any as any,
+    append as append,
+    arange as arange,
+    arccos as arccos,
+    arccosh as arccosh,
+    arcsin as arcsin,
+    arcsinh as arcsinh,
+    arctan as arctan,
+    arctan2 as arctan2,
+    arctanh as arctanh,
+    argmax as argmax,
+    argmin as argmin,
+    argsort as argsort,
+    around as around,
+    array as array,
+    asanyarray as asanyarray,
+    asarray as asarray,
+    bitwise_and as bitwise_and,
+    bitwise_or as bitwise_or,
+    bitwise_xor as bitwise_xor,
+    bool_ as bool_,
+    ceil as ceil,
+    choose as choose,
+    clip as clip,
+    common_fill_value as common_fill_value,
+    compress as compress,
+    compressed as compressed,
+    concatenate as concatenate,
+    conjugate as conjugate,
+    convolve as convolve,
+    copy as copy,
+    correlate as correlate,
+    cos as cos,
+    cosh as cosh,
+    count as count,
+    cumprod as cumprod,
+    cumsum as cumsum,
+    default_fill_value as default_fill_value,
+    diag as diag,
+    diagonal as diagonal,
+    diff as diff,
+    divide as divide,
+    empty as empty,
+    empty_like as empty_like,
+    equal as equal,
+    exp as exp,
+    expand_dims as expand_dims,
+    fabs as fabs,
+    filled as filled,
+    fix_invalid as fix_invalid,
+    flatten_mask as flatten_mask,
+    flatten_structured_array as flatten_structured_array,
+    floor as floor,
+    floor_divide as floor_divide,
+    fmod as fmod,
+    frombuffer as frombuffer,
+    fromflex as fromflex,
+    fromfunction as fromfunction,
+    getdata as getdata,
+    getmask as getmask,
+    getmaskarray as getmaskarray,
+    greater as greater,
+    greater_equal as greater_equal,
+    harden_mask as harden_mask,
+    hypot as hypot,
+    identity as identity,
+    ids as ids,
+    indices as indices,
+    inner as inner,
+    innerproduct as innerproduct,
+    isMA as isMA,
+    isMaskedArray as isMaskedArray,
+    is_mask as is_mask,
+    is_masked as is_masked,
+    isarray as isarray,
+    left_shift as left_shift,
+    less as less,
+    less_equal as less_equal,
+    log as log,
+    log10 as log10,
+    log2 as log2,
+    logical_and as logical_and,
+    logical_not as logical_not,
+    logical_or as logical_or,
+    logical_xor as logical_xor,
+    make_mask as make_mask,
+    make_mask_descr as make_mask_descr,
+    make_mask_none as make_mask_none,
+    mask_or as mask_or,
+    masked as masked,
+    masked_array as masked_array,
+    masked_equal as masked_equal,
+    masked_greater as masked_greater,
+    masked_greater_equal as masked_greater_equal,
+    masked_inside as masked_inside,
+    masked_invalid as masked_invalid,
+    masked_less as masked_less,
+    masked_less_equal as masked_less_equal,
+    masked_not_equal as masked_not_equal,
+    masked_object as masked_object,
+    masked_outside as masked_outside,
+    masked_print_option as masked_print_option,
+    masked_singleton as masked_singleton,
+    masked_values as masked_values,
+    masked_where as masked_where,
+    max as max,
+    maximum as maximum,
+    maximum_fill_value as maximum_fill_value,
+    mean as mean,
+    min as min,
+    minimum as minimum,
+    minimum_fill_value as minimum_fill_value,
+    mod as mod,
+    multiply as multiply,
+    mvoid as mvoid,
+    ndim as ndim,
+    negative as negative,
+    nomask as nomask,
+    nonzero as nonzero,
+    not_equal as not_equal,
+    ones as ones,
+    outer as outer,
+    outerproduct as outerproduct,
+    power as power,
+    prod as prod,
+    product as product,
+    ptp as ptp,
+    put as put,
+    putmask as putmask,
+    ravel as ravel,
+    remainder as remainder,
+    repeat as repeat,
+    reshape as reshape,
+    resize as resize,
+    right_shift as right_shift,
+    round as round,
+    set_fill_value as set_fill_value,
+    shape as shape,
+    sin as sin,
+    sinh as sinh,
+    size as size,
+    soften_mask as soften_mask,
+    sometrue as sometrue,
+    sort as sort,
+    sqrt as sqrt,
+    squeeze as squeeze,
+    std as std,
+    subtract as subtract,
+    sum as sum,
+    swapaxes as swapaxes,
+    take as take,
+    tan as tan,
+    tanh as tanh,
+    trace as trace,
+    transpose as transpose,
+    true_divide as true_divide,
+    var as var,
+    where as where,
+    zeros as zeros,
+)
+
+from numpy.ma.extras import (
+    apply_along_axis as apply_along_axis,
+    apply_over_axes as apply_over_axes,
+    atleast_1d as atleast_1d,
+    atleast_2d as atleast_2d,
+    atleast_3d as atleast_3d,
+    average as average,
+    clump_masked as clump_masked,
+    clump_unmasked as clump_unmasked,
+    column_stack as column_stack,
+    compress_cols as compress_cols,
+    compress_nd as compress_nd,
+    compress_rowcols as compress_rowcols,
+    compress_rows as compress_rows,
+    count_masked as count_masked,
+    corrcoef as corrcoef,
+    cov as cov,
+    diagflat as diagflat,
+    dot as dot,
+    dstack as dstack,
+    ediff1d as ediff1d,
+    flatnotmasked_contiguous as flatnotmasked_contiguous,
+    flatnotmasked_edges as flatnotmasked_edges,
+    hsplit as hsplit,
+    hstack as hstack,
+    isin as isin,
+    in1d as in1d,
+    intersect1d as intersect1d,
+    mask_cols as mask_cols,
+    mask_rowcols as mask_rowcols,
+    mask_rows as mask_rows,
+    masked_all as masked_all,
+    masked_all_like as masked_all_like,
+    median as median,
+    mr_ as mr_,
+    ndenumerate as ndenumerate,
+    notmasked_contiguous as notmasked_contiguous,
+    notmasked_edges as notmasked_edges,
+    polyfit as polyfit,
+    row_stack as row_stack,
+    setdiff1d as setdiff1d,
+    setxor1d as setxor1d,
+    stack as stack,
+    unique as unique,
+    union1d as union1d,
+    vander as vander,
+    vstack as vstack,
+)
+
+__all__: list[str]
+__path__: list[str]
+test: PytestTester