13 files changed, 3945 insertions, 139 deletions
diff --git a/numpy/core/src/multiarray/ctors.c b/numpy/core/src/multiarray/ctors.c
index c98d27512..52f21b61f 100644
--- a/numpy/core/src/multiarray/ctors.c
+++ b/numpy/core/src/multiarray/ctors.c
@@ -552,7 +552,7 @@ PyArray_AssignFromCache_Recursive(
             else {
                 PyArrayObject *view;
                 view = (PyArrayObject *)array_item_asarray(self, i);
-                if (view < 0) {
+                if (view == NULL) {
                     goto fail;
                 }
                 if (PyArray_AssignFromCache_Recursive(view, ndim, cache) < 0) {
diff --git a/numpy/core/src/multiarray/dtype_transfer.c b/numpy/core/src/multiarray/dtype_transfer.c
index ae3834e15..afa9c12a2 100644
--- a/numpy/core/src/multiarray/dtype_transfer.c
+++ b/numpy/core/src/multiarray/dtype_transfer.c
@@ -1331,10 +1331,10 @@ get_datetime_to_unicode_transfer_function(int aligned,
 
     /* Get an ASCII string data type, adapted to match the UNICODE one */
     str_dtype = PyArray_DescrNewFromType(NPY_STRING);
-    str_dtype->elsize = dst_dtype->elsize / 4;
     if (str_dtype == NULL) {
         return NPY_FAIL;
     }
+    str_dtype->elsize = dst_dtype->elsize / 4;
 
     /* Get the copy/swap operation to dst */
     if (PyArray_GetDTypeCopySwapFn(aligned,
diff --git a/numpy/core/src/multiarray/dtypemeta.c b/numpy/core/src/multiarray/dtypemeta.c
index b2f36d794..ddaf11042 100644
--- a/numpy/core/src/multiarray/dtypemeta.c
+++ b/numpy/core/src/multiarray/dtypemeta.c
@@ -162,12 +162,12 @@ void_discover_descr_from_pyobject(
     }
     if (PyBytes_Check(obj)) {
         PyArray_Descr *descr = PyArray_DescrNewFromType(NPY_VOID);
-        Py_ssize_t itemsize = (int)PyBytes_Size(obj);
+        Py_ssize_t itemsize = PyBytes_Size(obj);
         if (itemsize > NPY_MAX_INT) {
             PyErr_SetString(PyExc_TypeError,
                     "byte-like to large to store inside array.");
         }
-        descr->elsize = itemsize;
+        descr->elsize = (int)itemsize;
         return descr;
     }
     PyErr_Format(PyExc_TypeError,
diff --git a/numpy/random/__init__.pyi b/numpy/random/__init__.pyi
index b99c002ae..1187b7d8e 100644
--- a/numpy/random/__init__.pyi
+++ b/numpy/random/__init__.pyi
@@ -1,4 +1,4 @@
-from typing import Any, List
+from typing import List
 
 from numpy.random._generator import Generator as Generator
 from numpy.random._generator import default_rng as default_rng
@@ -8,57 +8,58 @@ from numpy.random._philox import Philox as Philox
 from numpy.random._sfc64 import SFC64 as SFC64
 from numpy.random.bit_generator import BitGenerator as BitGenerator
 from numpy.random.bit_generator import SeedSequence as SeedSequence
+from numpy.random.mtrand import (
+    RandomState as RandomState,
+    beta as beta,
+    binomial as binomial,
+    bytes as bytes,
+    chisquare as chisquare,
+    choice as choice,
+    dirichlet as dirichlet,
+    exponential as exponential,
+    f as f,
+    gamma as gamma,
+    geometric as geometric,
+    get_state as get_state,
+    gumbel as gumbel,
+    hypergeometric as hypergeometric,
+    laplace as laplace,
+    logistic as logistic,
+    lognormal as lognormal,
+    logseries as logseries,
+    multinomial as multinomial,
+    multivariate_normal as multivariate_normal,
+    negative_binomial as negative_binomial,
+    noncentral_chisquare as noncentral_chisquare,
+    noncentral_f as noncentral_f,
+    normal as normal,
+    pareto as pareto,
+    permutation as permutation,
+    poisson as poisson,
+    power as power,
+    rand as rand,
+    randint as randint,
+    randn as randn,
+    random as random,
+    random_integers as random_integers,
+    random_sample as random_sample,
+    ranf as ranf,
+    rayleigh as rayleigh,
+    sample as sample,
+    seed as seed,
+    set_state as set_state,
+    shuffle as shuffle,
+    standard_cauchy as standard_cauchy,
+    standard_exponential as standard_exponential,
+    standard_gamma as standard_gamma,
+    standard_normal as standard_normal,
+    standard_t as standard_t,
+    triangular as triangular,
+    uniform as uniform,
+    vonmises as vonmises,
+    wald as wald,
+    weibull as weibull,
+    zipf as zipf,
+)
 
 __all__: List[str]
-
-beta: Any
-binomial: Any
-bytes: Any
-chisquare: Any
-choice: Any
-dirichlet: Any
-exponential: Any
-f: Any
-gamma: Any
-geometric: Any
-get_state: Any
-gumbel: Any
-hypergeometric: Any
-laplace: Any
-logistic: Any
-lognormal: Any
-logseries: Any
-multinomial: Any
-multivariate_normal: Any
-negative_binomial: Any
-noncentral_chisquare: Any
-noncentral_f: Any
-normal: Any
-pareto: Any
-permutation: Any
-poisson: Any
-power: Any
-rand: Any
-randint: Any
-randn: Any
-random: Any
-random_integers: Any
-random_sample: Any
-ranf: Any
-rayleigh: Any
-sample: Any
-seed: Any
-set_state: Any
-shuffle: Any
-standard_cauchy: Any
-standard_exponential: Any
-standard_gamma: Any
-standard_normal: Any
-standard_t: Any
-triangular: Any
-uniform: Any
-vonmises: Any
-wald: Any
-weibull: Any
-zipf: Any
-RandomState: Any
diff --git a/numpy/random/_generator.pyi b/numpy/random/_generator.pyi
index aadc4d0f8..14dc55131 100644
--- a/numpy/random/_generator.pyi
+++ b/numpy/random/_generator.pyi
@@ -1,9 +1,8 @@
 import sys
-from typing import Any, Callable, Dict, Literal, Optional, Sequence, Tuple, Type, Union, overload
+from typing import Any, Callable, Dict, Optional, Tuple, Type, Union, overload, TypeVar
 
 from numpy import (
     bool_,
-    double,
     dtype,
     float32,
     float64,
@@ -13,7 +12,6 @@ from numpy import (
     int64,
     int_,
     ndarray,
-    single,
     uint,
     uint8,
     uint16,
@@ -25,7 +23,6 @@ from numpy.typing import (
     ArrayLike,
     _ArrayLikeFloat_co,
     _ArrayLikeInt_co,
-    _BoolCodes,
     _DoubleCodes,
     _DTypeLikeBool,
     _DTypeLikeInt,
@@ -52,6 +49,8 @@ if sys.version_info >= (3, 8):
 else:
     from typing_extensions import Literal
 
+_ArrayType = TypeVar("_ArrayType", bound=ndarray[Any, Any])
+
 _DTypeLikeFloat32 = Union[
     dtype[float32],
     _SupportsDType[dtype[float32]],
@@ -70,17 +69,15 @@ _DTypeLikeFloat64 = Union[
 ]
 
 class Generator:
-    # COMPLETE
     def __init__(self, bit_generator: BitGenerator) -> None: ...
     def __repr__(self) -> str: ...
     def __str__(self) -> str: ...
-    # Pickling support:
     def __getstate__(self) -> Dict[str, Any]: ...
     def __setstate__(self, state: Dict[str, Any]) -> None: ...
-    def __reduce__(self) -> Tuple[Callable[[str], BitGenerator], Tuple[str], Dict[str, Any]]: ...
+    def __reduce__(self) -> Tuple[Callable[[str], Generator], Tuple[str], Dict[str, Any]]: ...
     @property
     def bit_generator(self) -> BitGenerator: ...
-    def bytes(self, length: int) -> str: ...
+    def bytes(self, length: int) -> bytes: ...
     @overload
     def standard_normal(  # type: ignore[misc]
         self,
@@ -92,17 +89,31 @@ class Generator:
     def standard_normal(  # type: ignore[misc]
         self,
         size: _ShapeLike = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
-        out: Optional[ndarray[Any, dtype[Union[float32, float64]]]] = ...,
-    ) -> ndarray[Any, dtype[Union[float32, float64]]]: ...
+    ) -> ndarray[Any, dtype[float64]]: ...
     @overload
-    def permutation(self, x: int, axis: int = ...) -> ndarray[Any, dtype[int64]]: ...
+    def standard_normal(  # type: ignore[misc]
+        self,
+        *,
+        out: ndarray[Any, dtype[float64]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
     @overload
-    def permutation(self, x: ArrayLike, axis: int = ...) -> ndarray[Any, Any]: ...
+    def standard_normal(  # type: ignore[misc]
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+    ) -> ndarray[Any, dtype[float32]]: ...
     @overload
-    def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    def standard_normal(  # type: ignore[misc]
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
     @overload
-    def standard_cauchy(self, size: Optional[_ShapeLike] = ...) -> ndarray[Any, dtype[float64]]: ...
+    def permutation(self, x: int, axis: int = ...) -> ndarray[Any, dtype[int64]]: ...
+    @overload
+    def permutation(self, x: ArrayLike, axis: int = ...) -> ndarray[Any, Any]: ...
     @overload
     def standard_exponential(  # type: ignore[misc]
         self,
@@ -115,18 +126,37 @@ class Generator:
     def standard_exponential(
         self,
         size: _ShapeLike = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_exponential(
+        self,
+        *,
+        out: ndarray[Any, dtype[float64]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_exponential(
+        self,
+        size: _ShapeLike = ...,
+        *,
         method: Literal["zig", "inv"] = ...,
-        out: Optional[ndarray[Any, dtype[Union[float32, float64]]]] = ...,
-    ) -> ndarray[Any, dtype[Union[float32, float64]]]: ...
+        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def standard_exponential(
         self,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
         method: Literal["zig", "inv"] = ...,
-        out: ndarray[Any, dtype[Union[float32, float64]]] = ...,
-    ) -> ndarray[Any, dtype[Union[float32, float64]]]: ...
+        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+    ) -> ndarray[Any, dtype[float32]]: ...
+    @overload
+    def standard_exponential(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        method: Literal["zig", "inv"] = ...,
+        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def random(  # type: ignore[misc]
         self,
@@ -137,10 +167,30 @@ class Generator:
     @overload
     def random(
         self,
+        *,
+        out: ndarray[Any, dtype[float64]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def random(
+        self,
         size: _ShapeLike = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
-        out: Optional[ndarray[Any, dtype[Union[float32, float64]]]] = ...,
-    ) -> ndarray[Any, dtype[Union[float32, float64]]]: ...
+        *,
+        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def random(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+    ) -> ndarray[Any, dtype[float32]]: ...
+    @overload
+    def random(
+        self,
+        size: _ShapeLike = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        out: Optional[ndarray[Any, dtype[float64]]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def beta(self, a: float, b: float, size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
@@ -158,6 +208,12 @@ class Generator:
         self,
         low: int,
         high: Optional[int] = ...,
+    ) -> int: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: int,
+        high: Optional[int] = ...,
         size: None = ...,
         dtype: _DTypeLikeBool = ...,
         endpoint: bool = ...,
@@ -177,31 +233,16 @@ class Generator:
         low: _ArrayLikeInt_co,
         high: Optional[_ArrayLikeInt_co] = ...,
         size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[bool_], Type[bool], Type[bool_], _BoolCodes, _SupportsDType[dtype[bool_]]
-        ] = ...,
-        endpoint: bool = ...,
-    ) -> ndarray[Any, dtype[bool_]]: ...
-    @overload
-    def integers(  # type: ignore[misc]
-        self,
-        low: _ArrayLikeInt_co,
-        high: Optional[_ArrayLikeInt_co] = ...,
-        size: Optional[_ShapeLike] = ...,
-        dtype: Union[
-            dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
-        ] = ...,
-        endpoint: bool = ...,
-    ) -> ndarray[Any, dtype[int_]]: ...
+    ) -> ndarray[Any, dtype[int64]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
         low: _ArrayLikeInt_co,
         high: Optional[_ArrayLikeInt_co] = ...,
         size: Optional[_ShapeLike] = ...,
-        dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
+        dtype: _DTypeLikeBool = ...,
         endpoint: bool = ...,
-    ) -> ndarray[Any, dtype[uint]]: ...
+    ) -> ndarray[Any, dtype[bool_]]: ...
     @overload
     def integers(  # type: ignore[misc]
         self,
@@ -282,17 +323,68 @@ class Generator:
         ] = ...,
         endpoint: bool = ...,
     ) -> ndarray[Any, dtype[uint64]]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
+        ] = ...,
+        endpoint: bool = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def integers(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
+        endpoint: bool = ...,
+    ) -> ndarray[Any, dtype[uint]]: ...
     # TODO: Use a TypeVar _T here to get away from Any output?  Should be int->ndarray[Any,dtype[int64]], ArrayLike[_T] -> Union[_T, ndarray[Any,Any]]
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: None = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> int: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> ndarray[Any, dtype[int64]]: ...
+    @overload
     def choice(
         self,
         a: ArrayLike,
-        size: Optional[_ShapeLike] = ...,
+        size: None = ...,
         replace: bool = ...,
         p: Optional[_ArrayLikeFloat_co] = ...,
-        axis: Optional[int] = ...,
+        axis: int = ...,
         shuffle: bool = ...,
     ) -> Any: ...
     @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+        axis: int = ...,
+        shuffle: bool = ...,
+    ) -> ndarray[Any, Any]: ...
+    @overload
     def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def uniform(
@@ -323,8 +415,29 @@ class Generator:
         self,
         shape: _ArrayLikeFloat_co,
         size: Optional[_ShapeLike] = ...,
-        dtype: Union[_DTypeLikeFloat32, _DTypeLikeFloat64] = ...,
-        out: Optional[ndarray[Any, dtype[Union[float32, float64]]]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        *,
+        out: ndarray[Any, dtype[float64]] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+        dtype: _DTypeLikeFloat32 = ...,
+        out: Optional[ndarray[Any, dtype[float32]]] = ...,
+    ) -> ndarray[Any, dtype[float32]]: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+        dtype: _DTypeLikeFloat64 = ...,
+        out: Optional[ndarray[Any, dtype[float64]]] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
     def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
@@ -398,6 +511,10 @@ class Generator:
         self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
     ) -> ndarray[Any, dtype[float64]]: ...
     @overload
+    def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_cauchy(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
     def laplace(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
     @overload
     def laplace(
@@ -455,7 +572,6 @@ class Generator:
         right: _ArrayLikeFloat_co,
         size: Optional[_ShapeLike] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
-    # Complicated, discrete distributions:
     @overload
     def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
     @overload
@@ -502,7 +618,6 @@ class Generator:
     def logseries(
         self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
     ) -> ndarray[Any, dtype[int64]]: ...
-    # Multivariate distributions:
     def multivariate_normal(
         self,
         mean: _ArrayLikeFloat_co,
@@ -511,7 +626,7 @@ class Generator:
         check_valid: Literal["warn", "raise", "ignore"] = ...,
         tol: float = ...,
         *,
-        method: Literal["svd", "eigh", "cholesky"] = ...
+        method: Literal["svd", "eigh", "cholesky"] = ...,
     ) -> ndarray[Any, dtype[float64]]: ...
     def multinomial(
         self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
@@ -529,6 +644,8 @@ class Generator:
     def permuted(
         self, x: ArrayLike, *, axis: Optional[int] = ..., out: Optional[ndarray[Any, Any]] = ...
     ) -> ndarray[Any, Any]: ...
-    def shuffle(self, x: ArrayLike, axis: int = ...) -> Sequence[Any]: ...
+    def shuffle(self, x: ArrayLike, axis: int = ...) -> None: ...
 
-def default_rng(seed: Union[None, _ArrayLikeInt_co, SeedSequence] = ...) -> Generator: ...
+def default_rng(
+    seed: Union[None, _ArrayLikeInt_co, SeedSequence, BitGenerator, Generator] = ...
+) -> Generator: ...
diff --git a/numpy/random/_generator.pyx b/numpy/random/_generator.pyx
index 1912f8bed..f25f16a8a 100644
--- a/numpy/random/_generator.pyx
+++ b/numpy/random/_generator.pyx
@@ -644,6 +644,12 @@ cdef class Generator:
         --------
         integers, shuffle, permutation
 
+        Notes
+        -----
+        Setting user-specified probabilities through ``p`` uses a more general but less
+        efficient sampler than the default. The general sampler produces a different sample
+        than the optimized sampler even if each element of ``p`` is 1 / len(a).
+
         Examples
         --------
         Generate a uniform random sample from np.arange(5) of size 3:
@@ -3025,8 +3031,9 @@ cdef class Generator:
         Parameters
         ----------
         lam : float or array_like of floats
-            Expectation of interval, must be >= 0. A sequence of expectation
-            intervals must be broadcastable over the requested size.
+            Expected number of events occurring in a fixed-time interval,
+            must be >= 0. A sequence must be broadcastable over the requested
+            size.
         size : int or tuple of ints, optional
             Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
             ``m * n * k`` samples are drawn.  If size is ``None`` (default),
diff --git a/numpy/random/bit_generator.pyi b/numpy/random/bit_generator.pyi
index 80a2e829b..5b68dde6c 100644
--- a/numpy/random/bit_generator.pyi
+++ b/numpy/random/bit_generator.pyi
@@ -18,8 +18,8 @@ from typing import (
     overload,
 )
 
-from numpy import dtype, ndarray, uint32, uint64, unsignedinteger
-from numpy.typing import DTypeLike, _ArrayLikeInt_co, _DTypeLikeUInt, _ShapeLike, _SupportsDType
+from numpy import dtype, ndarray, uint32, uint64
+from numpy.typing import _ArrayLikeInt_co, _ShapeLike, _SupportsDType, _UInt32Codes, _UInt64Codes
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -28,11 +28,17 @@ else:
 
 _T = TypeVar("_T")
 
-_UIntType = TypeVar("_UIntType", uint64, uint32)
-_DTypeLike = Union[
-    Type[_UIntType],
-    dtype[_UIntType],
-    _SupportsDType[dtype[_UIntType]],
+_DTypeLikeUint32 = Union[
+    dtype[uint32],
+    _SupportsDType[dtype[uint32]],
+    Type[uint32],
+    _UInt32Codes,
+]
+_DTypeLikeUint64 = Union[
+    dtype[uint64],
+    _SupportsDType[dtype[uint64]],
+    Type[uint64],
+    _UInt64Codes,
 ]
 
 class _SeedSeqState(TypedDict):
@@ -50,30 +56,19 @@ class _Interface(NamedTuple):
     bit_generator: Any
 
 class ISeedSequence(abc.ABC):
-    @overload
-    @abc.abstractmethod
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLike[_UIntType] = ...
-    ) -> ndarray[Any, dtype[_UIntType]]: ...
-    @overload
     @abc.abstractmethod
     def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUInt = ...
-    ) -> ndarray[Any, dtype[unsignedinteger[Any]]]: ...
+        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
+    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
 
 class ISpawnableSeedSequence(ISeedSequence):
     @abc.abstractmethod
     def spawn(self: _T, n_children: int) -> List[_T]: ...
 
 class SeedlessSeedSequence(ISpawnableSeedSequence):
-    @overload
-    def generate_state(
-        self, n_words: int, dtype: _DTypeLike[_UIntType] = ...
-    ) -> ndarray[Any, dtype[_UIntType]]: ...
-    @overload
     def generate_state(
-        self, n_words: int, dtype: _DTypeLikeUInt = ...
-    ) -> ndarray[Any, dtype[unsignedinteger[Any]]]: ...
+        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
+    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
     def spawn(self: _T, n_children: int) -> List[_T]: ...
 
 class SeedSequence(ISpawnableSeedSequence):
@@ -84,7 +79,7 @@ class SeedSequence(ISpawnableSeedSequence):
     pool: ndarray[Any, dtype[uint32]]
     def __init__(
         self,
-        entropy: Union[None, int, Sequence[int]] = ...,
+        entropy: Union[None, int, Sequence[int], _ArrayLikeInt_co] = ...,
         *,
         spawn_key: Sequence[int] = ...,
         pool_size: int = ...,
@@ -95,7 +90,9 @@ class SeedSequence(ISpawnableSeedSequence):
     def state(
         self,
     ) -> _SeedSeqState: ...
-    def generate_state(self, n_words: int, dtype: DTypeLike = ...) -> ndarray[Any, Any]: ...
+    def generate_state(
+        self, n_words: int, dtype: Union[_DTypeLikeUint32, _DTypeLikeUint64] = ...
+    ) -> ndarray[Any, dtype[Union[uint32, uint64]]]: ...
     def spawn(self, n_children: int) -> List[SeedSequence]: ...
 
 class BitGenerator(abc.ABC):
diff --git a/numpy/random/mtrand.pyi b/numpy/random/mtrand.pyi
new file mode 100644
index 000000000..3137b0a95
--- /dev/null
+++ b/numpy/random/mtrand.pyi
@@ -0,0 +1,579 @@
+import sys
+from typing import Any, Callable, Dict, Optional, Tuple, Type, Union, overload
+
+from numpy import (
+    bool_,
+    dtype,
+    float32,
+    float64,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    ndarray,
+    uint,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+)
+from numpy.random.bit_generator import BitGenerator
+from numpy.typing import (
+    ArrayLike,
+    _ArrayLikeFloat_co,
+    _ArrayLikeInt_co,
+    _DoubleCodes,
+    _DTypeLikeBool,
+    _DTypeLikeInt,
+    _DTypeLikeUInt,
+    _Float32Codes,
+    _Float64Codes,
+    _Int8Codes,
+    _Int16Codes,
+    _Int32Codes,
+    _Int64Codes,
+    _IntCodes,
+    _ShapeLike,
+    _SingleCodes,
+    _SupportsDType,
+    _UInt8Codes,
+    _UInt16Codes,
+    _UInt32Codes,
+    _UInt64Codes,
+    _UIntCodes,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+_DTypeLikeFloat32 = Union[
+    dtype[float32],
+    _SupportsDType[dtype[float32]],
+    Type[float32],
+    _Float32Codes,
+    _SingleCodes,
+]
+
+_DTypeLikeFloat64 = Union[
+    dtype[float64],
+    _SupportsDType[dtype[float64]],
+    Type[float],
+    Type[float64],
+    _Float64Codes,
+    _DoubleCodes,
+]
+
+class RandomState:
+    _bit_generator: BitGenerator
+    def __init__(self, seed: Union[None, _ArrayLikeInt_co, BitGenerator] = ...) -> None: ...
+    def __repr__(self) -> str: ...
+    def __str__(self) -> str: ...
+    def __getstate__(self) -> Dict[str, Any]: ...
+    def __setstate__(self, state: Dict[str, Any]) -> None: ...
+    def __reduce__(self) -> Tuple[Callable[[str], RandomState], Tuple[str], Dict[str, Any]]: ...
+    def seed(self, seed: Optional[_ArrayLikeFloat_co] = ...) -> None: ...
+    @overload
+    def get_state(self, legacy: Literal[False] = ...) -> Dict[str, Any]: ...
+    @overload
+    def get_state(
+        self, legacy: Literal[True] = ...
+    ) -> Union[Dict[str, Any], Tuple[str, ndarray[Any, dtype[uint32]], int, int, float]]: ...
+    def set_state(
+        self, state: Union[Dict[str, Any], Tuple[str, ndarray[Any, dtype[uint32]], int, int, float]]
+    ) -> None: ...
+    @overload
+    def random_sample(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def random_sample(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def random(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def random(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def beta(self, a: float, b: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def beta(
+        self, a: _ArrayLikeFloat_co, b: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def exponential(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def exponential(
+        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_exponential(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_exponential(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def tomaxint(self, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def tomaxint(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: Optional[int] = ...,
+    ) -> int: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: Optional[int] = ...,
+        size: None = ...,
+        dtype: _DTypeLikeBool = ...,
+    ) -> bool: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: int,
+        high: Optional[int] = ...,
+        size: None = ...,
+        dtype: Union[_DTypeLikeInt, _DTypeLikeUInt] = ...,
+    ) -> int: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: _DTypeLikeBool = ...,
+    ) -> ndarray[Any, dtype[bool_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[int8], Type[int8], _Int8Codes, _SupportsDType[dtype[int8]]] = ...,
+    ) -> ndarray[Any, dtype[int8]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[int16], Type[int16], _Int16Codes, _SupportsDType[dtype[int16]]] = ...,
+    ) -> ndarray[Any, dtype[int16]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[int32], Type[int32], _Int32Codes, _SupportsDType[dtype[int32]]] = ...,
+    ) -> ndarray[Any, dtype[Union[int32]]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Optional[
+            Union[dtype[int64], Type[int64], _Int64Codes, _SupportsDType[dtype[int64]]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[int64]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[uint8], Type[uint8], _UInt8Codes, _SupportsDType[dtype[uint8]]] = ...,
+    ) -> ndarray[Any, dtype[uint8]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[uint16], Type[uint16], _UInt16Codes, _SupportsDType[dtype[uint16]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[Union[uint16]]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[uint32], Type[uint32], _UInt32Codes, _SupportsDType[dtype[uint32]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[uint32]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[uint64], Type[uint64], _UInt64Codes, _SupportsDType[dtype[uint64]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[uint64]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[
+            dtype[int_], Type[int], Type[int_], _IntCodes, _SupportsDType[dtype[int_]]
+        ] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def randint(  # type: ignore[misc]
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+        dtype: Union[dtype[uint], Type[uint], _UIntCodes, _SupportsDType[dtype[uint]]] = ...,
+    ) -> ndarray[Any, dtype[uint]]: ...
+    def bytes(self, length: int) -> bytes: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: None = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+    ) -> int: ...
+    @overload
+    def choice(
+        self,
+        a: int,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: None = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+    ) -> Any: ...
+    @overload
+    def choice(
+        self,
+        a: ArrayLike,
+        size: _ShapeLike = ...,
+        replace: bool = ...,
+        p: Optional[_ArrayLikeFloat_co] = ...,
+    ) -> ndarray[Any, Any]: ...
+    @overload
+    def uniform(self, low: float = ..., high: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def uniform(
+        self,
+        low: _ArrayLikeFloat_co = ...,
+        high: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def rand(self) -> float: ...
+    @overload
+    def rand(self, *args: int) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def randn(self) -> float: ...
+    @overload
+    def randn(self, *args: int) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def random_integers(self, low: int, high: Optional[int] = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def random_integers(
+        self,
+        low: _ArrayLikeInt_co,
+        high: Optional[_ArrayLikeInt_co] = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def standard_normal(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_normal(  # type: ignore[misc]
+        self, size: _ShapeLike = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def normal(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def normal(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_gamma(  # type: ignore[misc]
+        self,
+        shape: float,
+        size: None = ...,
+    ) -> float: ...
+    @overload
+    def standard_gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def gamma(self, shape: float, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gamma(
+        self,
+        shape: _ArrayLikeFloat_co,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def f(self, dfnum: float, dfden: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def f(
+        self, dfnum: _ArrayLikeFloat_co, dfden: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def noncentral_f(self, dfnum: float, dfden: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_f(
+        self,
+        dfnum: _ArrayLikeFloat_co,
+        dfden: _ArrayLikeFloat_co,
+        nonc: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def chisquare(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def chisquare(
+        self, df: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def noncentral_chisquare(self, df: float, nonc: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def noncentral_chisquare(
+        self, df: _ArrayLikeFloat_co, nonc: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_t(self, df: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: None = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_t(
+        self, df: _ArrayLikeFloat_co, size: _ShapeLike = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def vonmises(self, mu: float, kappa: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def vonmises(
+        self, mu: _ArrayLikeFloat_co, kappa: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def pareto(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def pareto(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def weibull(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def weibull(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def power(self, a: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def power(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def standard_cauchy(self, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def standard_cauchy(self, size: _ShapeLike = ...) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def laplace(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def laplace(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def gumbel(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def gumbel(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def logistic(self, loc: float = ..., scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def logistic(
+        self,
+        loc: _ArrayLikeFloat_co = ...,
+        scale: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def lognormal(self, mean: float = ..., sigma: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def lognormal(
+        self,
+        mean: _ArrayLikeFloat_co = ...,
+        sigma: _ArrayLikeFloat_co = ...,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def rayleigh(self, scale: float = ..., size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def rayleigh(
+        self, scale: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def wald(self, mean: float, scale: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def wald(
+        self, mean: _ArrayLikeFloat_co, scale: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def triangular(self, left: float, mode: float, right: float, size: None = ...) -> float: ...  # type: ignore[misc]
+    @overload
+    def triangular(
+        self,
+        left: _ArrayLikeFloat_co,
+        mode: _ArrayLikeFloat_co,
+        right: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    @overload
+    def binomial(self, n: int, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def binomial(
+        self, n: _ArrayLikeInt_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def negative_binomial(self, n: float, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def negative_binomial(
+        self, n: _ArrayLikeFloat_co, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def poisson(self, lam: float = ..., size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def poisson(
+        self, lam: _ArrayLikeFloat_co = ..., size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def zipf(self, a: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def zipf(
+        self, a: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def geometric(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def geometric(
+        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def hypergeometric(self, ngood: int, nbad: int, nsample: int, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def hypergeometric(
+        self,
+        ngood: _ArrayLikeInt_co,
+        nbad: _ArrayLikeInt_co,
+        nsample: _ArrayLikeInt_co,
+        size: Optional[_ShapeLike] = ...,
+    ) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def logseries(self, p: float, size: None = ...) -> int: ...  # type: ignore[misc]
+    @overload
+    def logseries(
+        self, p: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    def multivariate_normal(
+        self,
+        mean: _ArrayLikeFloat_co,
+        cov: _ArrayLikeFloat_co,
+        size: Optional[_ShapeLike] = ...,
+        check_valid: Literal["warn", "raise", "ignore"] = ...,
+        tol: float = ...,
+    ) -> ndarray[Any, dtype[float64]]: ...
+    def multinomial(
+        self, n: _ArrayLikeInt_co, pvals: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[int_]]: ...
+    def dirichlet(
+        self, alpha: _ArrayLikeFloat_co, size: Optional[_ShapeLike] = ...
+    ) -> ndarray[Any, dtype[float64]]: ...
+    def shuffle(self, x: ArrayLike) -> None: ...
+    @overload
+    def permutation(self, x: int) -> ndarray[Any, dtype[int_]]: ...
+    @overload
+    def permutation(self, x: ArrayLike) -> ndarray[Any, Any]: ...
+
+_rand: RandomState
+
+beta = _rand.beta
+binomial = _rand.binomial
+bytes = _rand.bytes
+chisquare = _rand.chisquare
+choice = _rand.choice
+dirichlet = _rand.dirichlet
+exponential = _rand.exponential
+f = _rand.f
+gamma = _rand.gamma
+get_state = _rand.get_state
+geometric = _rand.geometric
+gumbel = _rand.gumbel
+hypergeometric = _rand.hypergeometric
+laplace = _rand.laplace
+logistic = _rand.logistic
+lognormal = _rand.lognormal
+logseries = _rand.logseries
+multinomial = _rand.multinomial
+multivariate_normal = _rand.multivariate_normal
+negative_binomial = _rand.negative_binomial
+noncentral_chisquare = _rand.noncentral_chisquare
+noncentral_f = _rand.noncentral_f
+normal = _rand.normal
+pareto = _rand.pareto
+permutation = _rand.permutation
+poisson = _rand.poisson
+power = _rand.power
+rand = _rand.rand
+randint = _rand.randint
+randn = _rand.randn
+random = _rand.random
+random_integers = _rand.random_integers
+random_sample = _rand.random_sample
+rayleigh = _rand.rayleigh
+seed = _rand.seed
+set_state = _rand.set_state
+shuffle = _rand.shuffle
+standard_cauchy = _rand.standard_cauchy
+standard_exponential = _rand.standard_exponential
+standard_gamma = _rand.standard_gamma
+standard_normal = _rand.standard_normal
+standard_t = _rand.standard_t
+triangular = _rand.triangular
+uniform = _rand.uniform
+vonmises = _rand.vonmises
+wald = _rand.wald
+weibull = _rand.weibull
+zipf = _rand.zipf
+# Two legacy that are trivial wrappers around random_sample
+sample = _rand.random_sample
+ranf = _rand.random_sample
diff --git a/numpy/random/mtrand.pyx b/numpy/random/mtrand.pyx
index 1fd68111e..8d349b7d8 100644
--- a/numpy/random/mtrand.pyx
+++ b/numpy/random/mtrand.pyx
@@ -784,7 +784,7 @@ cdef class RandomState:
 
         Returns
         -------
-        out : str
+        out : bytes
             String of length `length`.
 
         See Also
@@ -852,6 +852,10 @@ cdef class RandomState:
 
         Notes
         -----
+        Setting user-specified probabilities through ``p`` uses a more general but less
+        efficient sampler than the default. The general sampler produces a different sample
+        than the optimized sampler even if each element of ``p`` is 1 / len(a).
+
         Sampling random rows from a 2-D array is not possible with this function,
         but is possible with `Generator.choice` through its ``axis`` keyword.
 
@@ -3524,8 +3528,9 @@ cdef class RandomState:
         Parameters
         ----------
         lam : float or array_like of floats
-            Expectation of interval, must be >= 0. A sequence of expectation
-            intervals must be broadcastable over the requested size.
+            Expected number of events occurring in a fixed-time interval,
+            must be >= 0. A sequence must be broadcastable over the requested
+            size.
         size : int or tuple of ints, optional
             Output shape.  If the given shape is, e.g., ``(m, n, k)``, then
             ``m * n * k`` samples are drawn.  If size is ``None`` (default),
diff --git a/numpy/typing/tests/data/fail/random.py b/numpy/typing/tests/data/fail/random.py
new file mode 100644
index 000000000..c4d1e3e3e
--- /dev/null
+++ b/numpy/typing/tests/data/fail/random.py
@@ -0,0 +1,61 @@
+import numpy as np
+from typing import Any, List
+
+SEED_FLOAT: float = 457.3
+SEED_ARR_FLOAT: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0, 2, 3, 4])
+SEED_ARRLIKE_FLOAT: List[float] = [1.0, 2.0, 3.0, 4.0]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_STR: str = "String seeding not allowed"
+# default rng
+np.random.default_rng(SEED_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.default_rng(SEED_STR)  # E: incompatible type
+
+# Seed Sequence
+np.random.SeedSequence(SEED_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.SeedSequence(SEED_SEED_SEQ)  # E: incompatible type
+np.random.SeedSequence(SEED_STR)  # E: incompatible type
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence()
+seed_seq.spawn(11.5)  # E: incompatible type
+seed_seq.generate_state(3.14)  # E: incompatible type
+seed_seq.generate_state(3, np.uint8)  # E: incompatible type
+seed_seq.generate_state(3, "uint8")  # E: incompatible type
+seed_seq.generate_state(3, "u1")  # E: incompatible type
+seed_seq.generate_state(3, np.uint16)  # E: incompatible type
+seed_seq.generate_state(3, "uint16")  # E: incompatible type
+seed_seq.generate_state(3, "u2")  # E: incompatible type
+seed_seq.generate_state(3, np.int32)  # E: incompatible type
+seed_seq.generate_state(3, "int32")  # E: incompatible type
+seed_seq.generate_state(3, "i4")  # E: incompatible type
+
+# Bit Generators
+np.random.MT19937(SEED_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.MT19937(SEED_STR)  # E: incompatible type
+
+np.random.PCG64(SEED_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.PCG64(SEED_STR)  # E: incompatible type
+
+np.random.Philox(SEED_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.Philox(SEED_STR)  # E: incompatible type
+
+np.random.SFC64(SEED_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_ARR_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_ARRLIKE_FLOAT)  # E: incompatible type
+np.random.SFC64(SEED_STR)  # E: incompatible type
+
+# Generator
+np.random.Generator(None)  # E: incompatible type
+np.random.Generator(12333283902830213)  # E: incompatible type
+np.random.Generator("OxFEEDF00D")  # E: incompatible type
+np.random.Generator([123, 234])  # E: incompatible type
+np.random.Generator(np.array([123, 234], dtype="u4"))  # E: incompatible type
diff --git a/numpy/typing/tests/data/pass/random.py b/numpy/typing/tests/data/pass/random.py
new file mode 100644
index 000000000..05bd62112
--- /dev/null
+++ b/numpy/typing/tests/data/pass/random.py
@@ -0,0 +1,1497 @@
+from __future__ import annotations
+
+from typing import Any, List, Dict
+
+import numpy as np
+
+SEED_NONE = None
+SEED_INT = 4579435749574957634658964293569
+SEED_ARR: np.ndarray[Any, np.dtype[np.int64]] = np.array([1, 2, 3, 4], dtype=np.int64)
+SEED_ARRLIKE: List[int] = [1, 2, 3, 4]
+SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0)
+SEED_MT19937: np.random.MT19937 = np.random.MT19937(0)
+SEED_PCG64: np.random.PCG64 = np.random.PCG64(0)
+SEED_PHILOX: np.random.Philox = np.random.Philox(0)
+SEED_SFC64: np.random.SFC64 = np.random.SFC64(0)
+
+# default rng
+np.random.default_rng()
+np.random.default_rng(SEED_NONE)
+np.random.default_rng(SEED_INT)
+np.random.default_rng(SEED_ARR)
+np.random.default_rng(SEED_ARRLIKE)
+np.random.default_rng(SEED_SEED_SEQ)
+np.random.default_rng(SEED_MT19937)
+np.random.default_rng(SEED_PCG64)
+np.random.default_rng(SEED_PHILOX)
+np.random.default_rng(SEED_SFC64)
+
+# Seed Sequence
+np.random.SeedSequence(SEED_NONE)
+np.random.SeedSequence(SEED_INT)
+np.random.SeedSequence(SEED_ARR)
+np.random.SeedSequence(SEED_ARRLIKE)
+
+# Bit Generators
+np.random.MT19937(SEED_NONE)
+np.random.MT19937(SEED_INT)
+np.random.MT19937(SEED_ARR)
+np.random.MT19937(SEED_ARRLIKE)
+np.random.MT19937(SEED_SEED_SEQ)
+
+np.random.PCG64(SEED_NONE)
+np.random.PCG64(SEED_INT)
+np.random.PCG64(SEED_ARR)
+np.random.PCG64(SEED_ARRLIKE)
+np.random.PCG64(SEED_SEED_SEQ)
+
+np.random.Philox(SEED_NONE)
+np.random.Philox(SEED_INT)
+np.random.Philox(SEED_ARR)
+np.random.Philox(SEED_ARRLIKE)
+np.random.Philox(SEED_SEED_SEQ)
+
+np.random.SFC64(SEED_NONE)
+np.random.SFC64(SEED_INT)
+np.random.SFC64(SEED_ARR)
+np.random.SFC64(SEED_ARRLIKE)
+np.random.SFC64(SEED_SEED_SEQ)
+
+seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence(SEED_NONE)
+seed_seq.spawn(10)
+seed_seq.generate_state(3)
+seed_seq.generate_state(3, "u4")
+seed_seq.generate_state(3, "uint32")
+seed_seq.generate_state(3, "u8")
+seed_seq.generate_state(3, "uint64")
+seed_seq.generate_state(3, np.uint32)
+seed_seq.generate_state(3, np.uint64)
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1])
+D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5])
+D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
+D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
+I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
+I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: List[float] = [0.1]
+D_arr_like_0p5: List[float] = [0.5]
+D_arr_like_0p9: List[float] = [0.9]
+D_arr_like_1p5: List[float] = [1.5]
+I_arr_like_10: List[int] = [10]
+I_arr_like_20: List[int] = [20]
+D_2D_like: List[List[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
+
+S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32)
+D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1)
+
+def_gen.standard_normal()
+def_gen.standard_normal(dtype=np.float32)
+def_gen.standard_normal(dtype="float32")
+def_gen.standard_normal(dtype="double")
+def_gen.standard_normal(dtype=np.float64)
+def_gen.standard_normal(size=None)
+def_gen.standard_normal(size=1)
+def_gen.standard_normal(size=1, dtype=np.float32)
+def_gen.standard_normal(size=1, dtype="f4")
+def_gen.standard_normal(size=1, dtype="float32", out=S_out)
+def_gen.standard_normal(dtype=np.float32, out=S_out)
+def_gen.standard_normal(size=1, dtype=np.float64)
+def_gen.standard_normal(size=1, dtype="float64")
+def_gen.standard_normal(size=1, dtype="f8")
+def_gen.standard_normal(out=D_out)
+def_gen.standard_normal(size=1, dtype="float64")
+def_gen.standard_normal(size=1, dtype="float64", out=D_out)
+
+def_gen.random()
+def_gen.random(dtype=np.float32)
+def_gen.random(dtype="float32")
+def_gen.random(dtype="double")
+def_gen.random(dtype=np.float64)
+def_gen.random(size=None)
+def_gen.random(size=1)
+def_gen.random(size=1, dtype=np.float32)
+def_gen.random(size=1, dtype="f4")
+def_gen.random(size=1, dtype="float32", out=S_out)
+def_gen.random(dtype=np.float32, out=S_out)
+def_gen.random(size=1, dtype=np.float64)
+def_gen.random(size=1, dtype="float64")
+def_gen.random(size=1, dtype="f8")
+def_gen.random(out=D_out)
+def_gen.random(size=1, dtype="float64")
+def_gen.random(size=1, dtype="float64", out=D_out)
+
+def_gen.standard_cauchy()
+def_gen.standard_cauchy(size=None)
+def_gen.standard_cauchy(size=1)
+
+def_gen.standard_exponential()
+def_gen.standard_exponential(method="inv")
+def_gen.standard_exponential(dtype=np.float32)
+def_gen.standard_exponential(dtype="float32")
+def_gen.standard_exponential(dtype="double")
+def_gen.standard_exponential(dtype=np.float64)
+def_gen.standard_exponential(size=None)
+def_gen.standard_exponential(size=None, method="inv")
+def_gen.standard_exponential(size=1, method="inv")
+def_gen.standard_exponential(size=1, dtype=np.float32)
+def_gen.standard_exponential(size=1, dtype="f4", method="inv")
+def_gen.standard_exponential(size=1, dtype="float32", out=S_out)
+def_gen.standard_exponential(dtype=np.float32, out=S_out)
+def_gen.standard_exponential(size=1, dtype=np.float64, method="inv")
+def_gen.standard_exponential(size=1, dtype="float64")
+def_gen.standard_exponential(size=1, dtype="f8")
+def_gen.standard_exponential(out=D_out)
+def_gen.standard_exponential(size=1, dtype="float64")
+def_gen.standard_exponential(size=1, dtype="float64", out=D_out)
+
+def_gen.zipf(1.5)
+def_gen.zipf(1.5, size=None)
+def_gen.zipf(1.5, size=1)
+def_gen.zipf(D_arr_1p5)
+def_gen.zipf(D_arr_1p5, size=1)
+def_gen.zipf(D_arr_like_1p5)
+def_gen.zipf(D_arr_like_1p5, size=1)
+
+def_gen.weibull(0.5)
+def_gen.weibull(0.5, size=None)
+def_gen.weibull(0.5, size=1)
+def_gen.weibull(D_arr_0p5)
+def_gen.weibull(D_arr_0p5, size=1)
+def_gen.weibull(D_arr_like_0p5)
+def_gen.weibull(D_arr_like_0p5, size=1)
+
+def_gen.standard_t(0.5)
+def_gen.standard_t(0.5, size=None)
+def_gen.standard_t(0.5, size=1)
+def_gen.standard_t(D_arr_0p5)
+def_gen.standard_t(D_arr_0p5, size=1)
+def_gen.standard_t(D_arr_like_0p5)
+def_gen.standard_t(D_arr_like_0p5, size=1)
+
+def_gen.poisson(0.5)
+def_gen.poisson(0.5, size=None)
+def_gen.poisson(0.5, size=1)
+def_gen.poisson(D_arr_0p5)
+def_gen.poisson(D_arr_0p5, size=1)
+def_gen.poisson(D_arr_like_0p5)
+def_gen.poisson(D_arr_like_0p5, size=1)
+
+def_gen.power(0.5)
+def_gen.power(0.5, size=None)
+def_gen.power(0.5, size=1)
+def_gen.power(D_arr_0p5)
+def_gen.power(D_arr_0p5, size=1)
+def_gen.power(D_arr_like_0p5)
+def_gen.power(D_arr_like_0p5, size=1)
+
+def_gen.pareto(0.5)
+def_gen.pareto(0.5, size=None)
+def_gen.pareto(0.5, size=1)
+def_gen.pareto(D_arr_0p5)
+def_gen.pareto(D_arr_0p5, size=1)
+def_gen.pareto(D_arr_like_0p5)
+def_gen.pareto(D_arr_like_0p5, size=1)
+
+def_gen.chisquare(0.5)
+def_gen.chisquare(0.5, size=None)
+def_gen.chisquare(0.5, size=1)
+def_gen.chisquare(D_arr_0p5)
+def_gen.chisquare(D_arr_0p5, size=1)
+def_gen.chisquare(D_arr_like_0p5)
+def_gen.chisquare(D_arr_like_0p5, size=1)
+
+def_gen.exponential(0.5)
+def_gen.exponential(0.5, size=None)
+def_gen.exponential(0.5, size=1)
+def_gen.exponential(D_arr_0p5)
+def_gen.exponential(D_arr_0p5, size=1)
+def_gen.exponential(D_arr_like_0p5)
+def_gen.exponential(D_arr_like_0p5, size=1)
+
+def_gen.geometric(0.5)
+def_gen.geometric(0.5, size=None)
+def_gen.geometric(0.5, size=1)
+def_gen.geometric(D_arr_0p5)
+def_gen.geometric(D_arr_0p5, size=1)
+def_gen.geometric(D_arr_like_0p5)
+def_gen.geometric(D_arr_like_0p5, size=1)
+
+def_gen.logseries(0.5)
+def_gen.logseries(0.5, size=None)
+def_gen.logseries(0.5, size=1)
+def_gen.logseries(D_arr_0p5)
+def_gen.logseries(D_arr_0p5, size=1)
+def_gen.logseries(D_arr_like_0p5)
+def_gen.logseries(D_arr_like_0p5, size=1)
+
+def_gen.rayleigh(0.5)
+def_gen.rayleigh(0.5, size=None)
+def_gen.rayleigh(0.5, size=1)
+def_gen.rayleigh(D_arr_0p5)
+def_gen.rayleigh(D_arr_0p5, size=1)
+def_gen.rayleigh(D_arr_like_0p5)
+def_gen.rayleigh(D_arr_like_0p5, size=1)
+
+def_gen.standard_gamma(0.5)
+def_gen.standard_gamma(0.5, size=None)
+def_gen.standard_gamma(0.5, dtype="float32")
+def_gen.standard_gamma(0.5, size=None, dtype="float32")
+def_gen.standard_gamma(0.5, size=1)
+def_gen.standard_gamma(D_arr_0p5)
+def_gen.standard_gamma(D_arr_0p5, dtype="f4")
+def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out)
+def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out)
+def_gen.standard_gamma(D_arr_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+def_gen.standard_gamma(0.5, out=D_out)
+def_gen.standard_gamma(D_arr_like_0p5, out=D_out)
+def_gen.standard_gamma(D_arr_like_0p5, size=1)
+def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64)
+
+def_gen.vonmises(0.5, 0.5)
+def_gen.vonmises(0.5, 0.5, size=None)
+def_gen.vonmises(0.5, 0.5, size=1)
+def_gen.vonmises(D_arr_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_0p5)
+def_gen.vonmises(D_arr_0p5, 0.5, size=1)
+def_gen.vonmises(0.5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, 0.5)
+def_gen.vonmises(0.5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.wald(0.5, 0.5)
+def_gen.wald(0.5, 0.5, size=None)
+def_gen.wald(0.5, 0.5, size=1)
+def_gen.wald(D_arr_0p5, 0.5)
+def_gen.wald(0.5, D_arr_0p5)
+def_gen.wald(D_arr_0p5, 0.5, size=1)
+def_gen.wald(0.5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, 0.5)
+def_gen.wald(0.5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.wald(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.uniform(0.5, 0.5)
+def_gen.uniform(0.5, 0.5, size=None)
+def_gen.uniform(0.5, 0.5, size=1)
+def_gen.uniform(D_arr_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_0p5)
+def_gen.uniform(D_arr_0p5, 0.5, size=1)
+def_gen.uniform(0.5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, 0.5)
+def_gen.uniform(0.5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.beta(0.5, 0.5)
+def_gen.beta(0.5, 0.5, size=None)
+def_gen.beta(0.5, 0.5, size=1)
+def_gen.beta(D_arr_0p5, 0.5)
+def_gen.beta(0.5, D_arr_0p5)
+def_gen.beta(D_arr_0p5, 0.5, size=1)
+def_gen.beta(0.5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, 0.5)
+def_gen.beta(0.5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.beta(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.f(0.5, 0.5)
+def_gen.f(0.5, 0.5, size=None)
+def_gen.f(0.5, 0.5, size=1)
+def_gen.f(D_arr_0p5, 0.5)
+def_gen.f(0.5, D_arr_0p5)
+def_gen.f(D_arr_0p5, 0.5, size=1)
+def_gen.f(0.5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, 0.5)
+def_gen.f(0.5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.f(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gamma(0.5, 0.5)
+def_gen.gamma(0.5, 0.5, size=None)
+def_gen.gamma(0.5, 0.5, size=1)
+def_gen.gamma(D_arr_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_0p5)
+def_gen.gamma(D_arr_0p5, 0.5, size=1)
+def_gen.gamma(0.5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, 0.5)
+def_gen.gamma(0.5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.gumbel(0.5, 0.5)
+def_gen.gumbel(0.5, 0.5, size=None)
+def_gen.gumbel(0.5, 0.5, size=1)
+def_gen.gumbel(D_arr_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_0p5)
+def_gen.gumbel(D_arr_0p5, 0.5, size=1)
+def_gen.gumbel(0.5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, 0.5)
+def_gen.gumbel(0.5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.laplace(0.5, 0.5)
+def_gen.laplace(0.5, 0.5, size=None)
+def_gen.laplace(0.5, 0.5, size=1)
+def_gen.laplace(D_arr_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_0p5)
+def_gen.laplace(D_arr_0p5, 0.5, size=1)
+def_gen.laplace(0.5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, 0.5)
+def_gen.laplace(0.5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.logistic(0.5, 0.5)
+def_gen.logistic(0.5, 0.5, size=None)
+def_gen.logistic(0.5, 0.5, size=1)
+def_gen.logistic(D_arr_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_0p5)
+def_gen.logistic(D_arr_0p5, 0.5, size=1)
+def_gen.logistic(0.5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, 0.5)
+def_gen.logistic(0.5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.lognormal(0.5, 0.5)
+def_gen.lognormal(0.5, 0.5, size=None)
+def_gen.lognormal(0.5, 0.5, size=1)
+def_gen.lognormal(D_arr_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_0p5)
+def_gen.lognormal(D_arr_0p5, 0.5, size=1)
+def_gen.lognormal(0.5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, 0.5)
+def_gen.lognormal(0.5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.noncentral_chisquare(0.5, 0.5)
+def_gen.noncentral_chisquare(0.5, 0.5, size=None)
+def_gen.noncentral_chisquare(0.5, 0.5, size=1)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5)
+def_gen.noncentral_chisquare(0.5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.normal(0.5, 0.5)
+def_gen.normal(0.5, 0.5, size=None)
+def_gen.normal(0.5, 0.5, size=1)
+def_gen.normal(D_arr_0p5, 0.5)
+def_gen.normal(0.5, D_arr_0p5)
+def_gen.normal(D_arr_0p5, 0.5, size=1)
+def_gen.normal(0.5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, 0.5)
+def_gen.normal(0.5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5)
+def_gen.normal(D_arr_0p5, D_arr_0p5, size=1)
+def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+def_gen.triangular(0.1, 0.5, 0.9)
+def_gen.triangular(0.1, 0.5, 0.9, size=None)
+def_gen.triangular(0.1, 0.5, 0.9, size=1)
+def_gen.triangular(D_arr_0p1, 0.5, 0.9)
+def_gen.triangular(0.1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.triangular(0.5, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.noncentral_f(0.1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=None)
+def_gen.noncentral_f(0.1, 0.5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+def_gen.binomial(10, 0.5)
+def_gen.binomial(10, 0.5, size=None)
+def_gen.binomial(10, 0.5, size=1)
+def_gen.binomial(I_arr_10, 0.5)
+def_gen.binomial(10, D_arr_0p5)
+def_gen.binomial(I_arr_10, 0.5, size=1)
+def_gen.binomial(10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, 0.5)
+def_gen.binomial(10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.negative_binomial(10, 0.5)
+def_gen.negative_binomial(10, 0.5, size=None)
+def_gen.negative_binomial(10, 0.5, size=1)
+def_gen.negative_binomial(I_arr_10, 0.5)
+def_gen.negative_binomial(10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_10, 0.5, size=1)
+def_gen.negative_binomial(10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, 0.5)
+def_gen.negative_binomial(10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+def_gen.hypergeometric(20, 20, 10)
+def_gen.hypergeometric(20, 20, 10, size=None)
+def_gen.hypergeometric(20, 20, 10, size=1)
+def_gen.hypergeometric(I_arr_20, 20, 10)
+def_gen.hypergeometric(20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+def_gen.hypergeometric(20, I_arr_20, 10, size=1)
+def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10)
+def_gen.hypergeometric(20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, 10)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+I_int64_100: np.ndarray[Any, np.dtype[np.int64]] = np.array([100], dtype=np.int64)
+
+def_gen.integers(0, 100)
+def_gen.integers(100)
+def_gen.integers([100])
+def_gen.integers(0, [100])
+
+I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_)
+I_bool_low_like: List[int] = [0]
+I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
+I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
+
+def_gen.integers(2, dtype=bool)
+def_gen.integers(0, 2, dtype=bool)
+def_gen.integers(1, dtype=bool, endpoint=True)
+def_gen.integers(0, 1, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_high_open, dtype=bool)
+def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool)
+def_gen.integers(0, I_bool_high_open, dtype=bool)
+def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True)
+def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True)
+def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True)
+
+def_gen.integers(2, dtype=np.bool_)
+def_gen.integers(0, 2, dtype=np.bool_)
+def_gen.integers(1, dtype=np.bool_, endpoint=True)
+def_gen.integers(0, 1, dtype=np.bool_, endpoint=True)
+def_gen.integers(I_bool_low_like, 1, dtype=np.bool_, endpoint=True)
+def_gen.integers(I_bool_high_open, dtype=np.bool_)
+def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool_)
+def_gen.integers(0, I_bool_high_open, dtype=np.bool_)
+def_gen.integers(I_bool_high_closed, dtype=np.bool_, endpoint=True)
+def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool_, endpoint=True)
+def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True)
+
+I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8)
+I_u1_low_like: List[int] = [0]
+I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+
+def_gen.integers(256, dtype="u1")
+def_gen.integers(0, 256, dtype="u1")
+def_gen.integers(255, dtype="u1", endpoint=True)
+def_gen.integers(0, 255, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_high_open, dtype="u1")
+def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1")
+def_gen.integers(0, I_u1_high_open, dtype="u1")
+def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True)
+
+def_gen.integers(256, dtype="uint8")
+def_gen.integers(0, 256, dtype="uint8")
+def_gen.integers(255, dtype="uint8", endpoint=True)
+def_gen.integers(0, 255, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_high_open, dtype="uint8")
+def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8")
+def_gen.integers(0, I_u1_high_open, dtype="uint8")
+def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True)
+
+def_gen.integers(256, dtype=np.uint8)
+def_gen.integers(0, 256, dtype=np.uint8)
+def_gen.integers(255, dtype=np.uint8, endpoint=True)
+def_gen.integers(0, 255, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_high_open, dtype=np.uint8)
+def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8)
+def_gen.integers(0, I_u1_high_open, dtype=np.uint8)
+def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True)
+def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True)
+def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True)
+
+I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16)
+I_u2_low_like: List[int] = [0]
+I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+
+def_gen.integers(65536, dtype="u2")
+def_gen.integers(0, 65536, dtype="u2")
+def_gen.integers(65535, dtype="u2", endpoint=True)
+def_gen.integers(0, 65535, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_high_open, dtype="u2")
+def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2")
+def_gen.integers(0, I_u2_high_open, dtype="u2")
+def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True)
+
+def_gen.integers(65536, dtype="uint16")
+def_gen.integers(0, 65536, dtype="uint16")
+def_gen.integers(65535, dtype="uint16", endpoint=True)
+def_gen.integers(0, 65535, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_high_open, dtype="uint16")
+def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16")
+def_gen.integers(0, I_u2_high_open, dtype="uint16")
+def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True)
+
+def_gen.integers(65536, dtype=np.uint16)
+def_gen.integers(0, 65536, dtype=np.uint16)
+def_gen.integers(65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_high_open, dtype=np.uint16)
+def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16)
+def_gen.integers(0, I_u2_high_open, dtype=np.uint16)
+def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True)
+def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True)
+def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True)
+
+I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32)
+I_u4_low_like: List[int] = [0]
+I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+
+def_gen.integers(4294967296, dtype="u4")
+def_gen.integers(0, 4294967296, dtype="u4")
+def_gen.integers(4294967295, dtype="u4", endpoint=True)
+def_gen.integers(0, 4294967295, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_high_open, dtype="u4")
+def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4")
+def_gen.integers(0, I_u4_high_open, dtype="u4")
+def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True)
+
+def_gen.integers(4294967296, dtype="uint32")
+def_gen.integers(0, 4294967296, dtype="uint32")
+def_gen.integers(4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_high_open, dtype="uint32")
+def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32")
+def_gen.integers(0, I_u4_high_open, dtype="uint32")
+def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True)
+
+def_gen.integers(4294967296, dtype=np.uint32)
+def_gen.integers(0, 4294967296, dtype=np.uint32)
+def_gen.integers(4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_high_open, dtype=np.uint32)
+def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32)
+def_gen.integers(0, I_u4_high_open, dtype=np.uint32)
+def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True)
+def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True)
+def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True)
+
+I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64)
+I_u8_low_like: List[int] = [0]
+I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+
+def_gen.integers(18446744073709551616, dtype="u8")
+def_gen.integers(0, 18446744073709551616, dtype="u8")
+def_gen.integers(18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_high_open, dtype="u8")
+def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8")
+def_gen.integers(0, I_u8_high_open, dtype="u8")
+def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True)
+
+def_gen.integers(18446744073709551616, dtype="uint64")
+def_gen.integers(0, 18446744073709551616, dtype="uint64")
+def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_high_open, dtype="uint64")
+def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64")
+def_gen.integers(0, I_u8_high_open, dtype="uint64")
+def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True)
+
+def_gen.integers(18446744073709551616, dtype=np.uint64)
+def_gen.integers(0, 18446744073709551616, dtype=np.uint64)
+def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_high_open, dtype=np.uint64)
+def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64)
+def_gen.integers(0, I_u8_high_open, dtype=np.uint64)
+def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True)
+def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True)
+def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True)
+
+I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8)
+I_i1_low_like: List[int] = [-128]
+I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+
+def_gen.integers(128, dtype="i1")
+def_gen.integers(-128, 128, dtype="i1")
+def_gen.integers(127, dtype="i1", endpoint=True)
+def_gen.integers(-128, 127, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_high_open, dtype="i1")
+def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1")
+def_gen.integers(-128, I_i1_high_open, dtype="i1")
+def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True)
+
+def_gen.integers(128, dtype="int8")
+def_gen.integers(-128, 128, dtype="int8")
+def_gen.integers(127, dtype="int8", endpoint=True)
+def_gen.integers(-128, 127, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_high_open, dtype="int8")
+def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8")
+def_gen.integers(-128, I_i1_high_open, dtype="int8")
+def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True)
+
+def_gen.integers(128, dtype=np.int8)
+def_gen.integers(-128, 128, dtype=np.int8)
+def_gen.integers(127, dtype=np.int8, endpoint=True)
+def_gen.integers(-128, 127, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_high_open, dtype=np.int8)
+def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8)
+def_gen.integers(-128, I_i1_high_open, dtype=np.int8)
+def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True)
+def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True)
+def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True)
+
+I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16)
+I_i2_low_like: List[int] = [-32768]
+I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+
+def_gen.integers(32768, dtype="i2")
+def_gen.integers(-32768, 32768, dtype="i2")
+def_gen.integers(32767, dtype="i2", endpoint=True)
+def_gen.integers(-32768, 32767, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_high_open, dtype="i2")
+def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2")
+def_gen.integers(-32768, I_i2_high_open, dtype="i2")
+def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True)
+
+def_gen.integers(32768, dtype="int16")
+def_gen.integers(-32768, 32768, dtype="int16")
+def_gen.integers(32767, dtype="int16", endpoint=True)
+def_gen.integers(-32768, 32767, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_high_open, dtype="int16")
+def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16")
+def_gen.integers(-32768, I_i2_high_open, dtype="int16")
+def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True)
+
+def_gen.integers(32768, dtype=np.int16)
+def_gen.integers(-32768, 32768, dtype=np.int16)
+def_gen.integers(32767, dtype=np.int16, endpoint=True)
+def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_high_open, dtype=np.int16)
+def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16)
+def_gen.integers(-32768, I_i2_high_open, dtype=np.int16)
+def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True)
+def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True)
+def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True)
+
+I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32)
+I_i4_low_like: List[int] = [-2147483648]
+I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+
+def_gen.integers(2147483648, dtype="i4")
+def_gen.integers(-2147483648, 2147483648, dtype="i4")
+def_gen.integers(2147483647, dtype="i4", endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_high_open, dtype="i4")
+def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4")
+def_gen.integers(-2147483648, I_i4_high_open, dtype="i4")
+def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True)
+
+def_gen.integers(2147483648, dtype="int32")
+def_gen.integers(-2147483648, 2147483648, dtype="int32")
+def_gen.integers(2147483647, dtype="int32", endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_high_open, dtype="int32")
+def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32")
+def_gen.integers(-2147483648, I_i4_high_open, dtype="int32")
+def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True)
+
+def_gen.integers(2147483648, dtype=np.int32)
+def_gen.integers(-2147483648, 2147483648, dtype=np.int32)
+def_gen.integers(2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_high_open, dtype=np.int32)
+def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32)
+def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32)
+def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True)
+def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True)
+def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True)
+
+I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64)
+I_i8_low_like: List[int] = [-9223372036854775808]
+I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+
+def_gen.integers(9223372036854775808, dtype="i8")
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8")
+def_gen.integers(9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_high_open, dtype="i8")
+def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8")
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8")
+def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True)
+
+def_gen.integers(9223372036854775808, dtype="int64")
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64")
+def_gen.integers(9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_high_open, dtype="int64")
+def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64")
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64")
+def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True)
+
+def_gen.integers(9223372036854775808, dtype=np.int64)
+def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64)
+def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_high_open, dtype=np.int64)
+def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64)
+def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64)
+def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True)
+def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True)
+def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True)
+
+
+def_gen.bit_generator
+
+def_gen.bytes(2)
+
+def_gen.choice(5)
+def_gen.choice(5, 3)
+def_gen.choice(5, 3, replace=True)
+def_gen.choice(5, 3, p=[1 / 5] * 5)
+def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"])
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+def_gen.dirichlet([0.5, 0.5])
+def_gen.dirichlet(np.array([0.5, 0.5]))
+def_gen.dirichlet(np.array([0.5, 0.5]), size=3)
+
+def_gen.multinomial(20, [1 / 6.0] * 6)
+def_gen.multinomial(20, np.array([0.5, 0.5]))
+def_gen.multinomial(20, [1 / 6.0] * 6, size=2)
+def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2))
+def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2))
+
+def_gen.multivariate_hypergeometric([3, 5, 7], 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4)
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7))
+def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count")
+def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals")
+
+def_gen.multivariate_normal([0.0], [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+def_gen.multivariate_normal(np.array([0.0]), [[1.0]])
+def_gen.multivariate_normal([0.0], np.array([[1.0]]))
+
+def_gen.permutation(10)
+def_gen.permutation([1, 2, 3, 4])
+def_gen.permutation(np.array([1, 2, 3, 4]))
+def_gen.permutation(D_2D, axis=1)
+def_gen.permuted(D_2D)
+def_gen.permuted(D_2D_like)
+def_gen.permuted(D_2D, axis=1)
+def_gen.permuted(D_2D, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D_like, out=D_2D)
+def_gen.permuted(D_2D, axis=1, out=D_2D)
+
+def_gen.shuffle(np.arange(10))
+def_gen.shuffle([1, 2, 3, 4, 5])
+def_gen.shuffle(D_2D, axis=1)
+
+def_gen.__str__()
+def_gen.__repr__()
+def_gen_state: Dict[str, Any]
+def_gen_state = def_gen.__getstate__()
+def_gen.__setstate__(def_gen_state)
+
+# RandomState
+random_st: np.random.RandomState = np.random.RandomState()
+
+random_st.standard_normal()
+random_st.standard_normal(size=None)
+random_st.standard_normal(size=1)
+
+random_st.random()
+random_st.random(size=None)
+random_st.random(size=1)
+
+random_st.standard_cauchy()
+random_st.standard_cauchy(size=None)
+random_st.standard_cauchy(size=1)
+
+random_st.standard_exponential()
+random_st.standard_exponential(size=None)
+random_st.standard_exponential(size=1)
+
+random_st.zipf(1.5)
+random_st.zipf(1.5, size=None)
+random_st.zipf(1.5, size=1)
+random_st.zipf(D_arr_1p5)
+random_st.zipf(D_arr_1p5, size=1)
+random_st.zipf(D_arr_like_1p5)
+random_st.zipf(D_arr_like_1p5, size=1)
+
+random_st.weibull(0.5)
+random_st.weibull(0.5, size=None)
+random_st.weibull(0.5, size=1)
+random_st.weibull(D_arr_0p5)
+random_st.weibull(D_arr_0p5, size=1)
+random_st.weibull(D_arr_like_0p5)
+random_st.weibull(D_arr_like_0p5, size=1)
+
+random_st.standard_t(0.5)
+random_st.standard_t(0.5, size=None)
+random_st.standard_t(0.5, size=1)
+random_st.standard_t(D_arr_0p5)
+random_st.standard_t(D_arr_0p5, size=1)
+random_st.standard_t(D_arr_like_0p5)
+random_st.standard_t(D_arr_like_0p5, size=1)
+
+random_st.poisson(0.5)
+random_st.poisson(0.5, size=None)
+random_st.poisson(0.5, size=1)
+random_st.poisson(D_arr_0p5)
+random_st.poisson(D_arr_0p5, size=1)
+random_st.poisson(D_arr_like_0p5)
+random_st.poisson(D_arr_like_0p5, size=1)
+
+random_st.power(0.5)
+random_st.power(0.5, size=None)
+random_st.power(0.5, size=1)
+random_st.power(D_arr_0p5)
+random_st.power(D_arr_0p5, size=1)
+random_st.power(D_arr_like_0p5)
+random_st.power(D_arr_like_0p5, size=1)
+
+random_st.pareto(0.5)
+random_st.pareto(0.5, size=None)
+random_st.pareto(0.5, size=1)
+random_st.pareto(D_arr_0p5)
+random_st.pareto(D_arr_0p5, size=1)
+random_st.pareto(D_arr_like_0p5)
+random_st.pareto(D_arr_like_0p5, size=1)
+
+random_st.chisquare(0.5)
+random_st.chisquare(0.5, size=None)
+random_st.chisquare(0.5, size=1)
+random_st.chisquare(D_arr_0p5)
+random_st.chisquare(D_arr_0p5, size=1)
+random_st.chisquare(D_arr_like_0p5)
+random_st.chisquare(D_arr_like_0p5, size=1)
+
+random_st.exponential(0.5)
+random_st.exponential(0.5, size=None)
+random_st.exponential(0.5, size=1)
+random_st.exponential(D_arr_0p5)
+random_st.exponential(D_arr_0p5, size=1)
+random_st.exponential(D_arr_like_0p5)
+random_st.exponential(D_arr_like_0p5, size=1)
+
+random_st.geometric(0.5)
+random_st.geometric(0.5, size=None)
+random_st.geometric(0.5, size=1)
+random_st.geometric(D_arr_0p5)
+random_st.geometric(D_arr_0p5, size=1)
+random_st.geometric(D_arr_like_0p5)
+random_st.geometric(D_arr_like_0p5, size=1)
+
+random_st.logseries(0.5)
+random_st.logseries(0.5, size=None)
+random_st.logseries(0.5, size=1)
+random_st.logseries(D_arr_0p5)
+random_st.logseries(D_arr_0p5, size=1)
+random_st.logseries(D_arr_like_0p5)
+random_st.logseries(D_arr_like_0p5, size=1)
+
+random_st.rayleigh(0.5)
+random_st.rayleigh(0.5, size=None)
+random_st.rayleigh(0.5, size=1)
+random_st.rayleigh(D_arr_0p5)
+random_st.rayleigh(D_arr_0p5, size=1)
+random_st.rayleigh(D_arr_like_0p5)
+random_st.rayleigh(D_arr_like_0p5, size=1)
+
+random_st.standard_gamma(0.5)
+random_st.standard_gamma(0.5, size=None)
+random_st.standard_gamma(0.5, size=1)
+random_st.standard_gamma(D_arr_0p5)
+random_st.standard_gamma(D_arr_0p5, size=1)
+random_st.standard_gamma(D_arr_like_0p5)
+random_st.standard_gamma(D_arr_like_0p5, size=1)
+random_st.standard_gamma(D_arr_like_0p5, size=1)
+
+random_st.vonmises(0.5, 0.5)
+random_st.vonmises(0.5, 0.5, size=None)
+random_st.vonmises(0.5, 0.5, size=1)
+random_st.vonmises(D_arr_0p5, 0.5)
+random_st.vonmises(0.5, D_arr_0p5)
+random_st.vonmises(D_arr_0p5, 0.5, size=1)
+random_st.vonmises(0.5, D_arr_0p5, size=1)
+random_st.vonmises(D_arr_like_0p5, 0.5)
+random_st.vonmises(0.5, D_arr_like_0p5)
+random_st.vonmises(D_arr_0p5, D_arr_0p5)
+random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5)
+random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1)
+random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.wald(0.5, 0.5)
+random_st.wald(0.5, 0.5, size=None)
+random_st.wald(0.5, 0.5, size=1)
+random_st.wald(D_arr_0p5, 0.5)
+random_st.wald(0.5, D_arr_0p5)
+random_st.wald(D_arr_0p5, 0.5, size=1)
+random_st.wald(0.5, D_arr_0p5, size=1)
+random_st.wald(D_arr_like_0p5, 0.5)
+random_st.wald(0.5, D_arr_like_0p5)
+random_st.wald(D_arr_0p5, D_arr_0p5)
+random_st.wald(D_arr_like_0p5, D_arr_like_0p5)
+random_st.wald(D_arr_0p5, D_arr_0p5, size=1)
+random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.uniform(0.5, 0.5)
+random_st.uniform(0.5, 0.5, size=None)
+random_st.uniform(0.5, 0.5, size=1)
+random_st.uniform(D_arr_0p5, 0.5)
+random_st.uniform(0.5, D_arr_0p5)
+random_st.uniform(D_arr_0p5, 0.5, size=1)
+random_st.uniform(0.5, D_arr_0p5, size=1)
+random_st.uniform(D_arr_like_0p5, 0.5)
+random_st.uniform(0.5, D_arr_like_0p5)
+random_st.uniform(D_arr_0p5, D_arr_0p5)
+random_st.uniform(D_arr_like_0p5, D_arr_like_0p5)
+random_st.uniform(D_arr_0p5, D_arr_0p5, size=1)
+random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.beta(0.5, 0.5)
+random_st.beta(0.5, 0.5, size=None)
+random_st.beta(0.5, 0.5, size=1)
+random_st.beta(D_arr_0p5, 0.5)
+random_st.beta(0.5, D_arr_0p5)
+random_st.beta(D_arr_0p5, 0.5, size=1)
+random_st.beta(0.5, D_arr_0p5, size=1)
+random_st.beta(D_arr_like_0p5, 0.5)
+random_st.beta(0.5, D_arr_like_0p5)
+random_st.beta(D_arr_0p5, D_arr_0p5)
+random_st.beta(D_arr_like_0p5, D_arr_like_0p5)
+random_st.beta(D_arr_0p5, D_arr_0p5, size=1)
+random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.f(0.5, 0.5)
+random_st.f(0.5, 0.5, size=None)
+random_st.f(0.5, 0.5, size=1)
+random_st.f(D_arr_0p5, 0.5)
+random_st.f(0.5, D_arr_0p5)
+random_st.f(D_arr_0p5, 0.5, size=1)
+random_st.f(0.5, D_arr_0p5, size=1)
+random_st.f(D_arr_like_0p5, 0.5)
+random_st.f(0.5, D_arr_like_0p5)
+random_st.f(D_arr_0p5, D_arr_0p5)
+random_st.f(D_arr_like_0p5, D_arr_like_0p5)
+random_st.f(D_arr_0p5, D_arr_0p5, size=1)
+random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.gamma(0.5, 0.5)
+random_st.gamma(0.5, 0.5, size=None)
+random_st.gamma(0.5, 0.5, size=1)
+random_st.gamma(D_arr_0p5, 0.5)
+random_st.gamma(0.5, D_arr_0p5)
+random_st.gamma(D_arr_0p5, 0.5, size=1)
+random_st.gamma(0.5, D_arr_0p5, size=1)
+random_st.gamma(D_arr_like_0p5, 0.5)
+random_st.gamma(0.5, D_arr_like_0p5)
+random_st.gamma(D_arr_0p5, D_arr_0p5)
+random_st.gamma(D_arr_like_0p5, D_arr_like_0p5)
+random_st.gamma(D_arr_0p5, D_arr_0p5, size=1)
+random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.gumbel(0.5, 0.5)
+random_st.gumbel(0.5, 0.5, size=None)
+random_st.gumbel(0.5, 0.5, size=1)
+random_st.gumbel(D_arr_0p5, 0.5)
+random_st.gumbel(0.5, D_arr_0p5)
+random_st.gumbel(D_arr_0p5, 0.5, size=1)
+random_st.gumbel(0.5, D_arr_0p5, size=1)
+random_st.gumbel(D_arr_like_0p5, 0.5)
+random_st.gumbel(0.5, D_arr_like_0p5)
+random_st.gumbel(D_arr_0p5, D_arr_0p5)
+random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5)
+random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1)
+random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.laplace(0.5, 0.5)
+random_st.laplace(0.5, 0.5, size=None)
+random_st.laplace(0.5, 0.5, size=1)
+random_st.laplace(D_arr_0p5, 0.5)
+random_st.laplace(0.5, D_arr_0p5)
+random_st.laplace(D_arr_0p5, 0.5, size=1)
+random_st.laplace(0.5, D_arr_0p5, size=1)
+random_st.laplace(D_arr_like_0p5, 0.5)
+random_st.laplace(0.5, D_arr_like_0p5)
+random_st.laplace(D_arr_0p5, D_arr_0p5)
+random_st.laplace(D_arr_like_0p5, D_arr_like_0p5)
+random_st.laplace(D_arr_0p5, D_arr_0p5, size=1)
+random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.logistic(0.5, 0.5)
+random_st.logistic(0.5, 0.5, size=None)
+random_st.logistic(0.5, 0.5, size=1)
+random_st.logistic(D_arr_0p5, 0.5)
+random_st.logistic(0.5, D_arr_0p5)
+random_st.logistic(D_arr_0p5, 0.5, size=1)
+random_st.logistic(0.5, D_arr_0p5, size=1)
+random_st.logistic(D_arr_like_0p5, 0.5)
+random_st.logistic(0.5, D_arr_like_0p5)
+random_st.logistic(D_arr_0p5, D_arr_0p5)
+random_st.logistic(D_arr_like_0p5, D_arr_like_0p5)
+random_st.logistic(D_arr_0p5, D_arr_0p5, size=1)
+random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.lognormal(0.5, 0.5)
+random_st.lognormal(0.5, 0.5, size=None)
+random_st.lognormal(0.5, 0.5, size=1)
+random_st.lognormal(D_arr_0p5, 0.5)
+random_st.lognormal(0.5, D_arr_0p5)
+random_st.lognormal(D_arr_0p5, 0.5, size=1)
+random_st.lognormal(0.5, D_arr_0p5, size=1)
+random_st.lognormal(D_arr_like_0p5, 0.5)
+random_st.lognormal(0.5, D_arr_like_0p5)
+random_st.lognormal(D_arr_0p5, D_arr_0p5)
+random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5)
+random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1)
+random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.noncentral_chisquare(0.5, 0.5)
+random_st.noncentral_chisquare(0.5, 0.5, size=None)
+random_st.noncentral_chisquare(0.5, 0.5, size=1)
+random_st.noncentral_chisquare(D_arr_0p5, 0.5)
+random_st.noncentral_chisquare(0.5, D_arr_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1)
+random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1)
+random_st.noncentral_chisquare(D_arr_like_0p5, 0.5)
+random_st.noncentral_chisquare(0.5, D_arr_like_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5)
+random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5)
+random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1)
+random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.normal(0.5, 0.5)
+random_st.normal(0.5, 0.5, size=None)
+random_st.normal(0.5, 0.5, size=1)
+random_st.normal(D_arr_0p5, 0.5)
+random_st.normal(0.5, D_arr_0p5)
+random_st.normal(D_arr_0p5, 0.5, size=1)
+random_st.normal(0.5, D_arr_0p5, size=1)
+random_st.normal(D_arr_like_0p5, 0.5)
+random_st.normal(0.5, D_arr_like_0p5)
+random_st.normal(D_arr_0p5, D_arr_0p5)
+random_st.normal(D_arr_like_0p5, D_arr_like_0p5)
+random_st.normal(D_arr_0p5, D_arr_0p5, size=1)
+random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1)
+
+random_st.triangular(0.1, 0.5, 0.9)
+random_st.triangular(0.1, 0.5, 0.9, size=None)
+random_st.triangular(0.1, 0.5, 0.9, size=1)
+random_st.triangular(D_arr_0p1, 0.5, 0.9)
+random_st.triangular(0.1, D_arr_0p5, 0.9)
+random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+random_st.triangular(0.1, D_arr_0p5, 0.9, size=1)
+random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9)
+random_st.triangular(0.5, D_arr_like_0p5, 0.9)
+random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9)
+random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+random_st.noncentral_f(0.1, 0.5, 0.9)
+random_st.noncentral_f(0.1, 0.5, 0.9, size=None)
+random_st.noncentral_f(0.1, 0.5, 0.9, size=1)
+random_st.noncentral_f(D_arr_0p1, 0.5, 0.9)
+random_st.noncentral_f(0.1, D_arr_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1)
+random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1)
+random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9)
+random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9)
+random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9)
+random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1)
+random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1)
+
+random_st.binomial(10, 0.5)
+random_st.binomial(10, 0.5, size=None)
+random_st.binomial(10, 0.5, size=1)
+random_st.binomial(I_arr_10, 0.5)
+random_st.binomial(10, D_arr_0p5)
+random_st.binomial(I_arr_10, 0.5, size=1)
+random_st.binomial(10, D_arr_0p5, size=1)
+random_st.binomial(I_arr_like_10, 0.5)
+random_st.binomial(10, D_arr_like_0p5)
+random_st.binomial(I_arr_10, D_arr_0p5)
+random_st.binomial(I_arr_like_10, D_arr_like_0p5)
+random_st.binomial(I_arr_10, D_arr_0p5, size=1)
+random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+random_st.negative_binomial(10, 0.5)
+random_st.negative_binomial(10, 0.5, size=None)
+random_st.negative_binomial(10, 0.5, size=1)
+random_st.negative_binomial(I_arr_10, 0.5)
+random_st.negative_binomial(10, D_arr_0p5)
+random_st.negative_binomial(I_arr_10, 0.5, size=1)
+random_st.negative_binomial(10, D_arr_0p5, size=1)
+random_st.negative_binomial(I_arr_like_10, 0.5)
+random_st.negative_binomial(10, D_arr_like_0p5)
+random_st.negative_binomial(I_arr_10, D_arr_0p5)
+random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5)
+random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1)
+random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1)
+
+random_st.hypergeometric(20, 20, 10)
+random_st.hypergeometric(20, 20, 10, size=None)
+random_st.hypergeometric(20, 20, 10, size=1)
+random_st.hypergeometric(I_arr_20, 20, 10)
+random_st.hypergeometric(20, I_arr_20, 10)
+random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1)
+random_st.hypergeometric(20, I_arr_20, 10, size=1)
+random_st.hypergeometric(I_arr_like_20, 20, I_arr_10)
+random_st.hypergeometric(20, I_arr_like_20, 10)
+random_st.hypergeometric(I_arr_20, I_arr_20, 10)
+random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10)
+random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1)
+random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1)
+
+random_st.randint(0, 100)
+random_st.randint(100)
+random_st.randint([100])
+random_st.randint(0, [100])
+
+random_st.randint(2, dtype=bool)
+random_st.randint(0, 2, dtype=bool)
+random_st.randint(I_bool_high_open, dtype=bool)
+random_st.randint(I_bool_low, I_bool_high_open, dtype=bool)
+random_st.randint(0, I_bool_high_open, dtype=bool)
+
+random_st.randint(2, dtype=np.bool_)
+random_st.randint(0, 2, dtype=np.bool_)
+random_st.randint(I_bool_high_open, dtype=np.bool_)
+random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool_)
+random_st.randint(0, I_bool_high_open, dtype=np.bool_)
+
+random_st.randint(256, dtype="u1")
+random_st.randint(0, 256, dtype="u1")
+random_st.randint(I_u1_high_open, dtype="u1")
+random_st.randint(I_u1_low, I_u1_high_open, dtype="u1")
+random_st.randint(0, I_u1_high_open, dtype="u1")
+
+random_st.randint(256, dtype="uint8")
+random_st.randint(0, 256, dtype="uint8")
+random_st.randint(I_u1_high_open, dtype="uint8")
+random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8")
+random_st.randint(0, I_u1_high_open, dtype="uint8")
+
+random_st.randint(256, dtype=np.uint8)
+random_st.randint(0, 256, dtype=np.uint8)
+random_st.randint(I_u1_high_open, dtype=np.uint8)
+random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8)
+random_st.randint(0, I_u1_high_open, dtype=np.uint8)
+
+random_st.randint(65536, dtype="u2")
+random_st.randint(0, 65536, dtype="u2")
+random_st.randint(I_u2_high_open, dtype="u2")
+random_st.randint(I_u2_low, I_u2_high_open, dtype="u2")
+random_st.randint(0, I_u2_high_open, dtype="u2")
+
+random_st.randint(65536, dtype="uint16")
+random_st.randint(0, 65536, dtype="uint16")
+random_st.randint(I_u2_high_open, dtype="uint16")
+random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16")
+random_st.randint(0, I_u2_high_open, dtype="uint16")
+
+random_st.randint(65536, dtype=np.uint16)
+random_st.randint(0, 65536, dtype=np.uint16)
+random_st.randint(I_u2_high_open, dtype=np.uint16)
+random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16)
+random_st.randint(0, I_u2_high_open, dtype=np.uint16)
+
+random_st.randint(4294967296, dtype="u4")
+random_st.randint(0, 4294967296, dtype="u4")
+random_st.randint(I_u4_high_open, dtype="u4")
+random_st.randint(I_u4_low, I_u4_high_open, dtype="u4")
+random_st.randint(0, I_u4_high_open, dtype="u4")
+
+random_st.randint(4294967296, dtype="uint32")
+random_st.randint(0, 4294967296, dtype="uint32")
+random_st.randint(I_u4_high_open, dtype="uint32")
+random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32")
+random_st.randint(0, I_u4_high_open, dtype="uint32")
+
+random_st.randint(4294967296, dtype=np.uint32)
+random_st.randint(0, 4294967296, dtype=np.uint32)
+random_st.randint(I_u4_high_open, dtype=np.uint32)
+random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32)
+random_st.randint(0, I_u4_high_open, dtype=np.uint32)
+
+
+random_st.randint(18446744073709551616, dtype="u8")
+random_st.randint(0, 18446744073709551616, dtype="u8")
+random_st.randint(I_u8_high_open, dtype="u8")
+random_st.randint(I_u8_low, I_u8_high_open, dtype="u8")
+random_st.randint(0, I_u8_high_open, dtype="u8")
+
+random_st.randint(18446744073709551616, dtype="uint64")
+random_st.randint(0, 18446744073709551616, dtype="uint64")
+random_st.randint(I_u8_high_open, dtype="uint64")
+random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64")
+random_st.randint(0, I_u8_high_open, dtype="uint64")
+
+random_st.randint(18446744073709551616, dtype=np.uint64)
+random_st.randint(0, 18446744073709551616, dtype=np.uint64)
+random_st.randint(I_u8_high_open, dtype=np.uint64)
+random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64)
+random_st.randint(0, I_u8_high_open, dtype=np.uint64)
+
+random_st.randint(128, dtype="i1")
+random_st.randint(-128, 128, dtype="i1")
+random_st.randint(I_i1_high_open, dtype="i1")
+random_st.randint(I_i1_low, I_i1_high_open, dtype="i1")
+random_st.randint(-128, I_i1_high_open, dtype="i1")
+
+random_st.randint(128, dtype="int8")
+random_st.randint(-128, 128, dtype="int8")
+random_st.randint(I_i1_high_open, dtype="int8")
+random_st.randint(I_i1_low, I_i1_high_open, dtype="int8")
+random_st.randint(-128, I_i1_high_open, dtype="int8")
+
+random_st.randint(128, dtype=np.int8)
+random_st.randint(-128, 128, dtype=np.int8)
+random_st.randint(I_i1_high_open, dtype=np.int8)
+random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8)
+random_st.randint(-128, I_i1_high_open, dtype=np.int8)
+
+random_st.randint(32768, dtype="i2")
+random_st.randint(-32768, 32768, dtype="i2")
+random_st.randint(I_i2_high_open, dtype="i2")
+random_st.randint(I_i2_low, I_i2_high_open, dtype="i2")
+random_st.randint(-32768, I_i2_high_open, dtype="i2")
+random_st.randint(32768, dtype="int16")
+random_st.randint(-32768, 32768, dtype="int16")
+random_st.randint(I_i2_high_open, dtype="int16")
+random_st.randint(I_i2_low, I_i2_high_open, dtype="int16")
+random_st.randint(-32768, I_i2_high_open, dtype="int16")
+random_st.randint(32768, dtype=np.int16)
+random_st.randint(-32768, 32768, dtype=np.int16)
+random_st.randint(I_i2_high_open, dtype=np.int16)
+random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16)
+random_st.randint(-32768, I_i2_high_open, dtype=np.int16)
+
+random_st.randint(2147483648, dtype="i4")
+random_st.randint(-2147483648, 2147483648, dtype="i4")
+random_st.randint(I_i4_high_open, dtype="i4")
+random_st.randint(I_i4_low, I_i4_high_open, dtype="i4")
+random_st.randint(-2147483648, I_i4_high_open, dtype="i4")
+
+random_st.randint(2147483648, dtype="int32")
+random_st.randint(-2147483648, 2147483648, dtype="int32")
+random_st.randint(I_i4_high_open, dtype="int32")
+random_st.randint(I_i4_low, I_i4_high_open, dtype="int32")
+random_st.randint(-2147483648, I_i4_high_open, dtype="int32")
+
+random_st.randint(2147483648, dtype=np.int32)
+random_st.randint(-2147483648, 2147483648, dtype=np.int32)
+random_st.randint(I_i4_high_open, dtype=np.int32)
+random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32)
+random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32)
+
+random_st.randint(9223372036854775808, dtype="i8")
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8")
+random_st.randint(I_i8_high_open, dtype="i8")
+random_st.randint(I_i8_low, I_i8_high_open, dtype="i8")
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8")
+
+random_st.randint(9223372036854775808, dtype="int64")
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64")
+random_st.randint(I_i8_high_open, dtype="int64")
+random_st.randint(I_i8_low, I_i8_high_open, dtype="int64")
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64")
+
+random_st.randint(9223372036854775808, dtype=np.int64)
+random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64)
+random_st.randint(I_i8_high_open, dtype=np.int64)
+random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64)
+random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64)
+
+bg: np.random.BitGenerator = random_st._bit_generator
+
+random_st.bytes(2)
+
+random_st.choice(5)
+random_st.choice(5, 3)
+random_st.choice(5, 3, replace=True)
+random_st.choice(5, 3, p=[1 / 5] * 5)
+random_st.choice(5, 3, p=[1 / 5] * 5, replace=False)
+
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"])
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True)
+random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4]))
+
+random_st.dirichlet([0.5, 0.5])
+random_st.dirichlet(np.array([0.5, 0.5]))
+random_st.dirichlet(np.array([0.5, 0.5]), size=3)
+
+random_st.multinomial(20, [1 / 6.0] * 6)
+random_st.multinomial(20, np.array([0.5, 0.5]))
+random_st.multinomial(20, [1 / 6.0] * 6, size=2)
+
+random_st.multivariate_normal([0.0], [[1.0]])
+random_st.multivariate_normal([0.0], np.array([[1.0]]))
+random_st.multivariate_normal(np.array([0.0]), [[1.0]])
+random_st.multivariate_normal([0.0], np.array([[1.0]]))
+
+random_st.permutation(10)
+random_st.permutation([1, 2, 3, 4])
+random_st.permutation(np.array([1, 2, 3, 4]))
+random_st.permutation(D_2D)
+
+random_st.shuffle(np.arange(10))
+random_st.shuffle([1, 2, 3, 4, 5])
+random_st.shuffle(D_2D)
+
+np.random.RandomState(SEED_PCG64)
+np.random.RandomState(0)
+np.random.RandomState([0, 1, 2])
+random_st.__str__()
+random_st.__repr__()
+random_st_state = random_st.__getstate__()
+random_st.__setstate__(random_st_state)
+random_st.seed()
+random_st.seed(1)
+random_st.seed([0, 1])
+random_st_get_state = random_st.get_state()
+random_st_get_state_legacy = random_st.get_state(legacy=True)
+random_st.set_state(random_st_get_state)
+
+random_st.rand()
+random_st.rand(1)
+random_st.rand(1, 2)
+random_st.randn()
+random_st.randn(1)
+random_st.randn(1, 2)
+random_st.random_sample()
+random_st.random_sample(1)
+random_st.random_sample(size=(1, 2))
+
+random_st.tomaxint()
+random_st.tomaxint(1)
+random_st.tomaxint((1,))
diff --git a/numpy/typing/tests/data/reveal/random.py b/numpy/typing/tests/data/reveal/random.py
new file mode 100644
index 000000000..6fc35aced
--- /dev/null
+++ b/numpy/typing/tests/data/reveal/random.py
@@ -0,0 +1,1539 @@
+from __future__ import annotations
+
+from typing import Any, List
+
+import numpy as np
+
+def_rng = np.random.default_rng()
+seed_seq = np.random.SeedSequence()
+mt19937 = np.random.MT19937()
+pcg64 = np.random.PCG64()
+sfc64 = np.random.SFC64()
+philox = np.random.Philox()
+seedless_seq = np.random.bit_generator.SeedlessSeedSequence()
+
+reveal_type(def_rng)  # E: numpy.random._generator.Generator
+reveal_type(mt19937)  # E: numpy.random._mt19937.MT19937
+reveal_type(pcg64)  # E: numpy.random._pcg64.PCG64
+reveal_type(sfc64)  # E: numpy.random._sfc64.SFC64
+reveal_type(philox)  # E: numpy.random._philox.Philox
+reveal_type(seed_seq)  # E: numpy.random.bit_generator.SeedSequence
+reveal_type(seedless_seq)  # E: numpy.random.bit_generator.SeedlessSeedSequence
+
+mt19937_jumped = mt19937.jumped()
+mt19937_jumped3 = mt19937.jumped(3)
+mt19937_raw = mt19937.random_raw()
+mt19937_raw_arr = mt19937.random_raw(5)
+
+reveal_type(mt19937_jumped)  # E: numpy.random._mt19937.MT19937
+reveal_type(mt19937_jumped3)  # E: numpy.random._mt19937.MT19937
+reveal_type(mt19937_raw)  # E: int
+reveal_type(mt19937_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(mt19937.lock)  # E: threading.Lock
+
+pcg64_jumped = pcg64.jumped()
+pcg64_jumped3 = pcg64.jumped(3)
+pcg64_adv = pcg64.advance(3)
+pcg64_raw = pcg64.random_raw()
+pcg64_raw_arr = pcg64.random_raw(5)
+
+reveal_type(pcg64_jumped)  # E: numpy.random._pcg64.PCG64
+reveal_type(pcg64_jumped3)  # E: numpy.random._pcg64.PCG64
+reveal_type(pcg64_adv)  # E: numpy.random._pcg64.PCG64
+reveal_type(pcg64_raw)  # E: int
+reveal_type(pcg64_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(pcg64.lock)  # E: threading.Lock
+
+philox_jumped = philox.jumped()
+philox_jumped3 = philox.jumped(3)
+philox_adv = philox.advance(3)
+philox_raw = philox.random_raw()
+philox_raw_arr = philox.random_raw(5)
+
+reveal_type(philox_jumped)  # E: numpy.random._philox.Philox
+reveal_type(philox_jumped3)  # E: numpy.random._philox.Philox
+reveal_type(philox_adv)  # E: numpy.random._philox.Philox
+reveal_type(philox_raw)  # E: int
+reveal_type(philox_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(philox.lock)  # E: threading.Lock
+
+sfc64_raw = sfc64.random_raw()
+sfc64_raw_arr = sfc64.random_raw(5)
+
+reveal_type(sfc64_raw)  # E: int
+reveal_type(sfc64_raw_arr)  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(sfc64.lock)  # E: threading.Lock
+
+reveal_type(seed_seq.pool)  # numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(seed_seq.entropy)  # E:Union[None, int, Sequence[int]]
+reveal_type(seed_seq.spawn(1))  # E: list[numpy.random.bit_generator.SeedSequence]
+reveal_type(seed_seq.generate_state(8, "uint32"))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.unsignedinteger[numpy.typing._32Bit], numpy.unsignedinteger[numpy.typing._64Bit]]]]
+reveal_type(seed_seq.generate_state(8, "uint64"))  # E: numpy.ndarray[Any, numpy.dtype[Union[numpy.unsignedinteger[numpy.typing._32Bit], numpy.unsignedinteger[numpy.typing._64Bit]]]]
+
+
+def_gen: np.random.Generator = np.random.default_rng()
+
+D_arr_0p1: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.1])
+D_arr_0p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.5])
+D_arr_0p9: np.ndarray[Any, np.dtype[np.float64]] = np.array([0.9])
+D_arr_1p5: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.5])
+I_arr_10: np.ndarray[Any, np.dtype[np.int_]] = np.array([10], dtype=np.int_)
+I_arr_20: np.ndarray[Any, np.dtype[np.int_]] = np.array([20], dtype=np.int_)
+D_arr_like_0p1: List[float] = [0.1]
+D_arr_like_0p5: List[float] = [0.5]
+D_arr_like_0p9: List[float] = [0.9]
+D_arr_like_1p5: List[float] = [1.5]
+I_arr_like_10: List[int] = [10]
+I_arr_like_20: List[int] = [20]
+D_2D_like: List[List[float]] = [[1, 2], [2, 3], [3, 4], [4, 5.1]]
+D_2D: np.ndarray[Any, np.dtype[np.float64]] = np.array(D_2D_like)
+S_out: np.ndarray[Any, np.dtype[np.float32]] = np.empty(1, dtype=np.float32)
+D_out: np.ndarray[Any, np.dtype[np.float64]] = np.empty(1)
+
+reveal_type(def_gen.standard_normal())  # E: float
+reveal_type(def_gen.standard_normal(dtype=np.float32))  # E: float
+reveal_type(def_gen.standard_normal(dtype="float32"))  # E: float
+reveal_type(def_gen.standard_normal(dtype="double"))  # E: float
+reveal_type(def_gen.standard_normal(dtype=np.float64))  # E: float
+reveal_type(def_gen.standard_normal(size=None))  # E: float
+reveal_type(def_gen.standard_normal(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype=np.float32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype="f4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype="float32", out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_normal(dtype=np.float32, out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype=np.float64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype="float64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype="f8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_normal(out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype="float64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_normal(size=1, dtype="float64", out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.random())  # E: float
+reveal_type(def_gen.random(dtype=np.float32))  # E: float
+reveal_type(def_gen.random(dtype="float32"))  # E: float
+reveal_type(def_gen.random(dtype="double"))  # E: float
+reveal_type(def_gen.random(dtype=np.float64))  # E: float
+reveal_type(def_gen.random(size=None))  # E: float
+reveal_type(def_gen.random(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.random(size=1, dtype=np.float32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.random(size=1, dtype="f4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.random(size=1, dtype="float32", out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.random(dtype=np.float32, out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.random(size=1, dtype=np.float64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.random(size=1, dtype="float64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.random(size=1, dtype="f8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.random(out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.random(size=1, dtype="float64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.random(size=1, dtype="float64", out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.standard_cauchy())  # E: float
+reveal_type(def_gen.standard_cauchy(size=None))  # E: float
+reveal_type(def_gen.standard_cauchy(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.standard_exponential())  # E: float
+reveal_type(def_gen.standard_exponential(method="inv"))  # E: float
+reveal_type(def_gen.standard_exponential(dtype=np.float32))  # E: float
+reveal_type(def_gen.standard_exponential(dtype="float32"))  # E: float
+reveal_type(def_gen.standard_exponential(dtype="double"))  # E: float
+reveal_type(def_gen.standard_exponential(dtype=np.float64))  # E: float
+reveal_type(def_gen.standard_exponential(size=None))  # E: float
+reveal_type(def_gen.standard_exponential(size=None, method="inv"))  # E: float
+reveal_type(def_gen.standard_exponential(size=1, method="inv"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype=np.float32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype="f4", method="inv"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype="float32", out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_exponential(dtype=np.float32, out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype=np.float64, method="inv"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype="float64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype="f8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_exponential(out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype="float64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_exponential(size=1, dtype="float64", out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.zipf(1.5))  # E: int
+reveal_type(def_gen.zipf(1.5, size=None))  # E: int
+reveal_type(def_gen.zipf(1.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.zipf(D_arr_1p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.zipf(D_arr_1p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.zipf(D_arr_like_1p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.zipf(D_arr_like_1p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.weibull(0.5))  # E: float
+reveal_type(def_gen.weibull(0.5, size=None))  # E: float
+reveal_type(def_gen.weibull(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.weibull(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.standard_t(0.5))  # E: float
+reveal_type(def_gen.standard_t(0.5, size=None))  # E: float
+reveal_type(def_gen.standard_t(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.standard_t(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.poisson(0.5))  # E: int
+reveal_type(def_gen.poisson(0.5, size=None))  # E: int
+reveal_type(def_gen.poisson(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.poisson(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.poisson(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.poisson(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.poisson(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.power(0.5))  # E: float
+reveal_type(def_gen.power(0.5, size=None))  # E: float
+reveal_type(def_gen.power(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.power(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.pareto(0.5))  # E: float
+reveal_type(def_gen.pareto(0.5, size=None))  # E: float
+reveal_type(def_gen.pareto(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.pareto(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.chisquare(0.5))  # E: float
+reveal_type(def_gen.chisquare(0.5, size=None))  # E: float
+reveal_type(def_gen.chisquare(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.chisquare(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.exponential(0.5))  # E: float
+reveal_type(def_gen.exponential(0.5, size=None))  # E: float
+reveal_type(def_gen.exponential(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.exponential(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.geometric(0.5))  # E: int
+reveal_type(def_gen.geometric(0.5, size=None))  # E: int
+reveal_type(def_gen.geometric(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.geometric(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.geometric(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.geometric(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.geometric(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.logseries(0.5))  # E: int
+reveal_type(def_gen.logseries(0.5, size=None))  # E: int
+reveal_type(def_gen.logseries(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.logseries(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.logseries(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.logseries(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.logseries(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.rayleigh(0.5))  # E: float
+reveal_type(def_gen.rayleigh(0.5, size=None))  # E: float
+reveal_type(def_gen.rayleigh(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.rayleigh(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.standard_gamma(0.5))  # E: float
+reveal_type(def_gen.standard_gamma(0.5, size=None))  # E: float
+reveal_type(def_gen.standard_gamma(0.5, dtype="float32"))  # E: float
+reveal_type(def_gen.standard_gamma(0.5, size=None, dtype="float32"))  # E: float
+reveal_type(def_gen.standard_gamma(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_0p5, dtype="f4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_gamma(0.5, size=1, dtype="float32", out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_0p5, dtype=np.float32, out=S_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._32Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(0.5, out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5, out=D_out))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(def_gen.standard_gamma(D_arr_like_0p5, size=1, out=D_out, dtype=np.float64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.vonmises(0.5, 0.5))  # E: float
+reveal_type(def_gen.vonmises(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.vonmises(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.wald(0.5, 0.5))  # E: float
+reveal_type(def_gen.wald(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.wald(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.wald(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.uniform(0.5, 0.5))  # E: float
+reveal_type(def_gen.uniform(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.uniform(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.beta(0.5, 0.5))  # E: float
+reveal_type(def_gen.beta(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.beta(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.beta(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.f(0.5, 0.5))  # E: float
+reveal_type(def_gen.f(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.f(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.f(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.gamma(0.5, 0.5))  # E: float
+reveal_type(def_gen.gamma(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.gamma(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.gumbel(0.5, 0.5))  # E: float
+reveal_type(def_gen.gumbel(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.gumbel(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.laplace(0.5, 0.5))  # E: float
+reveal_type(def_gen.laplace(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.laplace(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.logistic(0.5, 0.5))  # E: float
+reveal_type(def_gen.logistic(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.logistic(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.lognormal(0.5, 0.5))  # E: float
+reveal_type(def_gen.lognormal(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.lognormal(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.noncentral_chisquare(0.5, 0.5))  # E: float
+reveal_type(def_gen.noncentral_chisquare(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.noncentral_chisquare(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.normal(0.5, 0.5))  # E: float
+reveal_type(def_gen.normal(0.5, 0.5, size=None))  # E: float
+reveal_type(def_gen.normal(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.normal(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.triangular(0.1, 0.5, 0.9))  # E: float
+reveal_type(def_gen.triangular(0.1, 0.5, 0.9, size=None))  # E: float
+reveal_type(def_gen.triangular(0.1, 0.5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, 0.5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(0.1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(0.1, D_arr_0p5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_like_0p1, 0.5, D_arr_0p9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(0.5, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9))  # E: float
+reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=None))  # E: float
+reveal_type(def_gen.noncentral_f(0.1, 0.5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, 0.5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(0.1, D_arr_0p5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(0.5, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.binomial(10, 0.5))  # E: int
+reveal_type(def_gen.binomial(10, 0.5, size=None))  # E: int
+reveal_type(def_gen.binomial(10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_like_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.binomial(I_arr_like_10, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.negative_binomial(10, 0.5))  # E: int
+reveal_type(def_gen.negative_binomial(10, 0.5, size=None))  # E: int
+reveal_type(def_gen.negative_binomial(10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_like_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.hypergeometric(20, 20, 10))  # E: int
+reveal_type(def_gen.hypergeometric(20, 20, 10, size=None))  # E: int
+reveal_type(def_gen.hypergeometric(20, 20, 10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_20, 20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(20, I_arr_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(20, I_arr_20, 10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_like_20, 20, I_arr_10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(20, I_arr_like_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_20, I_arr_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+I_int64_100: np.ndarray[Any, np.dtype[np.int64]] = np.array([100], dtype=np.int64)
+
+reveal_type(def_gen.integers(0, 100))  # E: int
+reveal_type(def_gen.integers(100))  # E: int
+reveal_type(def_gen.integers([100]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, [100]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+I_bool_low: np.ndarray[Any, np.dtype[np.bool_]] = np.array([0], dtype=np.bool_)
+I_bool_low_like: List[int] = [0]
+I_bool_high_open: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
+I_bool_high_closed: np.ndarray[Any, np.dtype[np.bool_]] = np.array([1], dtype=np.bool_)
+
+reveal_type(def_gen.integers(2, dtype=bool))  # E: builtins.bool
+reveal_type(def_gen.integers(0, 2, dtype=bool))  # E: builtins.bool
+reveal_type(def_gen.integers(1, dtype=bool, endpoint=True))  # E: builtins.bool
+reveal_type(def_gen.integers(0, 1, dtype=bool, endpoint=True))  # E: builtins.bool
+reveal_type(def_gen.integers(I_bool_low_like, 1, dtype=bool, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_high_open, dtype=bool))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_low, I_bool_high_open, dtype=bool))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(0, I_bool_high_open, dtype=bool))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_high_closed, dtype=bool, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=bool, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(0, I_bool_high_closed, dtype=bool, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+
+reveal_type(def_gen.integers(2, dtype=np.bool_))  # E: builtins.bool
+reveal_type(def_gen.integers(0, 2, dtype=np.bool_))  # E: builtins.bool
+reveal_type(def_gen.integers(1, dtype=np.bool_, endpoint=True))  # E: builtins.bool
+reveal_type(def_gen.integers(0, 1, dtype=np.bool_, endpoint=True))  # E: builtins.bool
+reveal_type(def_gen.integers(I_bool_low_like, 1, dtype=np.bool_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_high_open, dtype=np.bool_))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_low, I_bool_high_open, dtype=np.bool_))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(0, I_bool_high_open, dtype=np.bool_))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_high_closed, dtype=np.bool_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(I_bool_low, I_bool_high_closed, dtype=np.bool_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(def_gen.integers(0, I_bool_high_closed, dtype=np.bool_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+
+I_u1_low: np.ndarray[Any, np.dtype[np.uint8]] = np.array([0], dtype=np.uint8)
+I_u1_low_like: List[int] = [0]
+I_u1_high_open: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+I_u1_high_closed: np.ndarray[Any, np.dtype[np.uint8]] = np.array([255], dtype=np.uint8)
+
+reveal_type(def_gen.integers(256, dtype="u1"))  # E: int
+reveal_type(def_gen.integers(0, 256, dtype="u1"))  # E: int
+reveal_type(def_gen.integers(255, dtype="u1", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 255, dtype="u1", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u1_low_like, 255, dtype="u1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_high_open, dtype="u1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype="u1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(0, I_u1_high_open, dtype="u1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_high_closed, dtype="u1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype="u1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(0, I_u1_high_closed, dtype="u1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+
+reveal_type(def_gen.integers(256, dtype="uint8"))  # E: int
+reveal_type(def_gen.integers(0, 256, dtype="uint8"))  # E: int
+reveal_type(def_gen.integers(255, dtype="uint8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 255, dtype="uint8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u1_low_like, 255, dtype="uint8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_high_open, dtype="uint8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype="uint8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(0, I_u1_high_open, dtype="uint8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_high_closed, dtype="uint8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype="uint8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(0, I_u1_high_closed, dtype="uint8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+
+reveal_type(def_gen.integers(256, dtype=np.uint8))  # E: int
+reveal_type(def_gen.integers(0, 256, dtype=np.uint8))  # E: int
+reveal_type(def_gen.integers(255, dtype=np.uint8, endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 255, dtype=np.uint8, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u1_low_like, 255, dtype=np.uint8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_high_open, dtype=np.uint8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_low, I_u1_high_open, dtype=np.uint8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(0, I_u1_high_open, dtype=np.uint8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_high_closed, dtype=np.uint8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_u1_low, I_u1_high_closed, dtype=np.uint8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(0, I_u1_high_closed, dtype=np.uint8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+
+I_u2_low: np.ndarray[Any, np.dtype[np.uint16]] = np.array([0], dtype=np.uint16)
+I_u2_low_like: List[int] = [0]
+I_u2_high_open: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+I_u2_high_closed: np.ndarray[Any, np.dtype[np.uint16]] = np.array([65535], dtype=np.uint16)
+
+reveal_type(def_gen.integers(65536, dtype="u2"))  # E: int
+reveal_type(def_gen.integers(0, 65536, dtype="u2"))  # E: int
+reveal_type(def_gen.integers(65535, dtype="u2", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 65535, dtype="u2", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u2_low_like, 65535, dtype="u2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_high_open, dtype="u2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype="u2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(0, I_u2_high_open, dtype="u2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_high_closed, dtype="u2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype="u2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(0, I_u2_high_closed, dtype="u2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+
+reveal_type(def_gen.integers(65536, dtype="uint16"))  # E: int
+reveal_type(def_gen.integers(0, 65536, dtype="uint16"))  # E: int
+reveal_type(def_gen.integers(65535, dtype="uint16", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 65535, dtype="uint16", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u2_low_like, 65535, dtype="uint16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_high_open, dtype="uint16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype="uint16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(0, I_u2_high_open, dtype="uint16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_high_closed, dtype="uint16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype="uint16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(0, I_u2_high_closed, dtype="uint16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+
+reveal_type(def_gen.integers(65536, dtype=np.uint16))  # E: int
+reveal_type(def_gen.integers(0, 65536, dtype=np.uint16))  # E: int
+reveal_type(def_gen.integers(65535, dtype=np.uint16, endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 65535, dtype=np.uint16, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u2_low_like, 65535, dtype=np.uint16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_high_open, dtype=np.uint16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_low, I_u2_high_open, dtype=np.uint16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(0, I_u2_high_open, dtype=np.uint16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_high_closed, dtype=np.uint16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_u2_low, I_u2_high_closed, dtype=np.uint16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(0, I_u2_high_closed, dtype=np.uint16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+
+I_u4_low: np.ndarray[Any, np.dtype[np.uint32]] = np.array([0], dtype=np.uint32)
+I_u4_low_like: List[int] = [0]
+I_u4_high_open: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+I_u4_high_closed: np.ndarray[Any, np.dtype[np.uint32]] = np.array([4294967295], dtype=np.uint32)
+
+reveal_type(def_gen.integers(4294967296, dtype=np.int_))  # E: int
+reveal_type(def_gen.integers(0, 4294967296, dtype=np.int_))  # E: int
+reveal_type(def_gen.integers(4294967295, dtype=np.int_, endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 4294967295, dtype=np.int_, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.int_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(def_gen.integers(I_u4_high_open, dtype=np.int_))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.int_))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(def_gen.integers(0, I_u4_high_open, dtype=np.int_))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(def_gen.integers(I_u4_high_closed, dtype=np.int_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.int_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.int_, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+
+reveal_type(def_gen.integers(4294967296, dtype="u4"))  # E: int
+reveal_type(def_gen.integers(0, 4294967296, dtype="u4"))  # E: int
+reveal_type(def_gen.integers(4294967295, dtype="u4", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 4294967295, dtype="u4", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype="u4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_high_open, dtype="u4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype="u4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(0, I_u4_high_open, dtype="u4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_high_closed, dtype="u4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype="u4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(0, I_u4_high_closed, dtype="u4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+
+reveal_type(def_gen.integers(4294967296, dtype="uint32"))  # E: int
+reveal_type(def_gen.integers(0, 4294967296, dtype="uint32"))  # E: int
+reveal_type(def_gen.integers(4294967295, dtype="uint32", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 4294967295, dtype="uint32", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype="uint32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_high_open, dtype="uint32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype="uint32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(0, I_u4_high_open, dtype="uint32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_high_closed, dtype="uint32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype="uint32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(0, I_u4_high_closed, dtype="uint32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+
+reveal_type(def_gen.integers(4294967296, dtype=np.uint32))  # E: int
+reveal_type(def_gen.integers(0, 4294967296, dtype=np.uint32))  # E: int
+reveal_type(def_gen.integers(4294967295, dtype=np.uint32, endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 4294967295, dtype=np.uint32, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_high_open, dtype=np.uint32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(0, I_u4_high_open, dtype=np.uint32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_high_closed, dtype=np.uint32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+
+reveal_type(def_gen.integers(4294967296, dtype=np.uint))  # E: int
+reveal_type(def_gen.integers(0, 4294967296, dtype=np.uint))  # E: int
+reveal_type(def_gen.integers(4294967295, dtype=np.uint, endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 4294967295, dtype=np.uint, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u4_low_like, 4294967295, dtype=np.uint, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(def_gen.integers(I_u4_high_open, dtype=np.uint))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_open, dtype=np.uint))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(def_gen.integers(0, I_u4_high_open, dtype=np.uint))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(def_gen.integers(I_u4_high_closed, dtype=np.uint, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(def_gen.integers(I_u4_low, I_u4_high_closed, dtype=np.uint, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(def_gen.integers(0, I_u4_high_closed, dtype=np.uint, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+
+I_u8_low: np.ndarray[Any, np.dtype[np.uint64]] = np.array([0], dtype=np.uint64)
+I_u8_low_like: List[int] = [0]
+I_u8_high_open: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+I_u8_high_closed: np.ndarray[Any, np.dtype[np.uint64]] = np.array([18446744073709551615], dtype=np.uint64)
+
+reveal_type(def_gen.integers(18446744073709551616, dtype="u8"))  # E: int
+reveal_type(def_gen.integers(0, 18446744073709551616, dtype="u8"))  # E: int
+reveal_type(def_gen.integers(18446744073709551615, dtype="u8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 18446744073709551615, dtype="u8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="u8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_high_open, dtype="u8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype="u8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, I_u8_high_open, dtype="u8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_high_closed, dtype="u8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype="u8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, I_u8_high_closed, dtype="u8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.integers(18446744073709551616, dtype="uint64"))  # E: int
+reveal_type(def_gen.integers(0, 18446744073709551616, dtype="uint64"))  # E: int
+reveal_type(def_gen.integers(18446744073709551615, dtype="uint64", endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 18446744073709551615, dtype="uint64", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype="uint64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_high_open, dtype="uint64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype="uint64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, I_u8_high_open, dtype="uint64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_high_closed, dtype="uint64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype="uint64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, I_u8_high_closed, dtype="uint64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.integers(18446744073709551616, dtype=np.uint64))  # E: int
+reveal_type(def_gen.integers(0, 18446744073709551616, dtype=np.uint64))  # E: int
+reveal_type(def_gen.integers(18446744073709551615, dtype=np.uint64, endpoint=True))  # E: int
+reveal_type(def_gen.integers(0, 18446744073709551615, dtype=np.uint64, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_u8_low_like, 18446744073709551615, dtype=np.uint64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_high_open, dtype=np.uint64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_low, I_u8_high_open, dtype=np.uint64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, I_u8_high_open, dtype=np.uint64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_high_closed, dtype=np.uint64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_u8_low, I_u8_high_closed, dtype=np.uint64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(0, I_u8_high_closed, dtype=np.uint64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+
+I_i1_low: np.ndarray[Any, np.dtype[np.int8]] = np.array([-128], dtype=np.int8)
+I_i1_low_like: List[int] = [-128]
+I_i1_high_open: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+I_i1_high_closed: np.ndarray[Any, np.dtype[np.int8]] = np.array([127], dtype=np.int8)
+
+reveal_type(def_gen.integers(128, dtype="i1"))  # E: int
+reveal_type(def_gen.integers(-128, 128, dtype="i1"))  # E: int
+reveal_type(def_gen.integers(127, dtype="i1", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-128, 127, dtype="i1", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i1_low_like, 127, dtype="i1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_high_open, dtype="i1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype="i1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(-128, I_i1_high_open, dtype="i1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_high_closed, dtype="i1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype="i1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype="i1", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+
+reveal_type(def_gen.integers(128, dtype="int8"))  # E: int
+reveal_type(def_gen.integers(-128, 128, dtype="int8"))  # E: int
+reveal_type(def_gen.integers(127, dtype="int8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-128, 127, dtype="int8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i1_low_like, 127, dtype="int8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_high_open, dtype="int8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype="int8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(-128, I_i1_high_open, dtype="int8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_high_closed, dtype="int8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype="int8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype="int8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+
+reveal_type(def_gen.integers(128, dtype=np.int8))  # E: int
+reveal_type(def_gen.integers(-128, 128, dtype=np.int8))  # E: int
+reveal_type(def_gen.integers(127, dtype=np.int8, endpoint=True))  # E: int
+reveal_type(def_gen.integers(-128, 127, dtype=np.int8, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i1_low_like, 127, dtype=np.int8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_high_open, dtype=np.int8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_low, I_i1_high_open, dtype=np.int8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(-128, I_i1_high_open, dtype=np.int8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_high_closed, dtype=np.int8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(I_i1_low, I_i1_high_closed, dtype=np.int8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(def_gen.integers(-128, I_i1_high_closed, dtype=np.int8, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+
+I_i2_low: np.ndarray[Any, np.dtype[np.int16]] = np.array([-32768], dtype=np.int16)
+I_i2_low_like: List[int] = [-32768]
+I_i2_high_open: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+I_i2_high_closed: np.ndarray[Any, np.dtype[np.int16]] = np.array([32767], dtype=np.int16)
+
+reveal_type(def_gen.integers(32768, dtype="i2"))  # E: int
+reveal_type(def_gen.integers(-32768, 32768, dtype="i2"))  # E: int
+reveal_type(def_gen.integers(32767, dtype="i2", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-32768, 32767, dtype="i2", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i2_low_like, 32767, dtype="i2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_high_open, dtype="i2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype="i2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(-32768, I_i2_high_open, dtype="i2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_high_closed, dtype="i2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype="i2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype="i2", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+
+reveal_type(def_gen.integers(32768, dtype="int16"))  # E: int
+reveal_type(def_gen.integers(-32768, 32768, dtype="int16"))  # E: int
+reveal_type(def_gen.integers(32767, dtype="int16", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-32768, 32767, dtype="int16", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i2_low_like, 32767, dtype="int16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_high_open, dtype="int16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype="int16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(-32768, I_i2_high_open, dtype="int16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_high_closed, dtype="int16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype="int16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype="int16", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+
+reveal_type(def_gen.integers(32768, dtype=np.int16))  # E: int
+reveal_type(def_gen.integers(-32768, 32768, dtype=np.int16))  # E: int
+reveal_type(def_gen.integers(32767, dtype=np.int16, endpoint=True))  # E: int
+reveal_type(def_gen.integers(-32768, 32767, dtype=np.int16, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i2_low_like, 32767, dtype=np.int16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_high_open, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_low, I_i2_high_open, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(-32768, I_i2_high_open, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_high_closed, dtype=np.int16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(I_i2_low, I_i2_high_closed, dtype=np.int16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(def_gen.integers(-32768, I_i2_high_closed, dtype=np.int16, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+
+I_i4_low: np.ndarray[Any, np.dtype[np.int32]] = np.array([-2147483648], dtype=np.int32)
+I_i4_low_like: List[int] = [-2147483648]
+I_i4_high_open: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+I_i4_high_closed: np.ndarray[Any, np.dtype[np.int32]] = np.array([2147483647], dtype=np.int32)
+
+reveal_type(def_gen.integers(2147483648, dtype="i4"))  # E: int
+reveal_type(def_gen.integers(-2147483648, 2147483648, dtype="i4"))  # E: int
+reveal_type(def_gen.integers(2147483647, dtype="i4", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-2147483648, 2147483647, dtype="i4", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i4_low_like, 2147483647, dtype="i4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_high_open, dtype="i4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype="i4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(-2147483648, I_i4_high_open, dtype="i4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_high_closed, dtype="i4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype="i4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype="i4", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+
+reveal_type(def_gen.integers(2147483648, dtype="int32"))  # E: int
+reveal_type(def_gen.integers(-2147483648, 2147483648, dtype="int32"))  # E: int
+reveal_type(def_gen.integers(2147483647, dtype="int32", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-2147483648, 2147483647, dtype="int32", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i4_low_like, 2147483647, dtype="int32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_high_open, dtype="int32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype="int32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(-2147483648, I_i4_high_open, dtype="int32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_high_closed, dtype="int32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype="int32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype="int32", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+
+reveal_type(def_gen.integers(2147483648, dtype=np.int32))  # E: int
+reveal_type(def_gen.integers(-2147483648, 2147483648, dtype=np.int32))  # E: int
+reveal_type(def_gen.integers(2147483647, dtype=np.int32, endpoint=True))  # E: int
+reveal_type(def_gen.integers(-2147483648, 2147483647, dtype=np.int32, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i4_low_like, 2147483647, dtype=np.int32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_high_open, dtype=np.int32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_low, I_i4_high_open, dtype=np.int32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(-2147483648, I_i4_high_open, dtype=np.int32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_high_closed, dtype=np.int32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(I_i4_low, I_i4_high_closed, dtype=np.int32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(def_gen.integers(-2147483648, I_i4_high_closed, dtype=np.int32, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+
+I_i8_low: np.ndarray[Any, np.dtype[np.int64]] = np.array([-9223372036854775808], dtype=np.int64)
+I_i8_low_like: List[int] = [-9223372036854775808]
+I_i8_high_open: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+I_i8_high_closed: np.ndarray[Any, np.dtype[np.int64]] = np.array([9223372036854775807], dtype=np.int64)
+
+reveal_type(def_gen.integers(9223372036854775808, dtype="i8"))  # E: int
+reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="i8"))  # E: int
+reveal_type(def_gen.integers(9223372036854775807, dtype="i8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="i8", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="i8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_high_open, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_high_closed, dtype="i8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype="i8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="i8", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.integers(9223372036854775808, dtype="int64"))  # E: int
+reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype="int64"))  # E: int
+reveal_type(def_gen.integers(9223372036854775807, dtype="int64", endpoint=True))  # E: int
+reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype="int64", endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype="int64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_high_open, dtype="int64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype="int64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype="int64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_high_closed, dtype="int64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype="int64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype="int64", endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.integers(9223372036854775808, dtype=np.int64))  # E: int
+reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775808, dtype=np.int64))  # E: int
+reveal_type(def_gen.integers(9223372036854775807, dtype=np.int64, endpoint=True))  # E: int
+reveal_type(def_gen.integers(-9223372036854775808, 9223372036854775807, dtype=np.int64, endpoint=True))  # E: int
+reveal_type(def_gen.integers(I_i8_low_like, 9223372036854775807, dtype=np.int64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_high_open, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_low, I_i8_high_open, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_open, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_high_closed, dtype=np.int64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(I_i8_low, I_i8_high_closed, dtype=np.int64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.integers(-9223372036854775808, I_i8_high_closed, dtype=np.int64, endpoint=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+
+reveal_type(def_gen.bit_generator)  # E: BitGenerator
+
+reveal_type(def_gen.bytes(2))  # E: bytes
+
+reveal_type(def_gen.choice(5))  # E: int
+reveal_type(def_gen.choice(5, 3))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.choice(5, 3, replace=True))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.choice(5, 3, p=[1 / 5] * 5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.choice(5, 3, p=[1 / 5] * 5, replace=False))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"]))  # E: Any
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])))  # E: numpy.ndarray[Any, Any]
+
+reveal_type(def_gen.dirichlet([0.5, 0.5]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.dirichlet(np.array([0.5, 0.5])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.dirichlet(np.array([0.5, 0.5]), size=3))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.multinomial(20, [1 / 6.0] * 6))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multinomial(20, np.array([0.5, 0.5])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multinomial(20, [1 / 6.0] * 6, size=2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multinomial([[10], [20]], [1 / 6.0] * 6, size=(2, 2)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multinomial(np.array([[10], [20]]), np.array([0.5, 0.5]), size=(2, 2)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=4))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, size=(4, 7)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multivariate_hypergeometric([3, 5, 7], 2, method="count"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.multivariate_hypergeometric(np.array([3, 5, 7]), 2, method="marginals"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(def_gen.multivariate_normal([0.0], [[1.0]]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_normal([0.0], np.array([[1.0]])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_normal(np.array([0.0]), [[1.0]]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(def_gen.multivariate_normal([0.0], np.array([[1.0]])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(def_gen.permutation(10))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(def_gen.permutation([1, 2, 3, 4]))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permutation(np.array([1, 2, 3, 4])))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permutation(D_2D, axis=1))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D_like))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D, axis=1))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D, out=D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D_like, out=D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D_like, out=D_2D))  # E: numpy.ndarray[Any, Any]
+reveal_type(def_gen.permuted(D_2D, axis=1, out=D_2D))  # E: numpy.ndarray[Any, Any]
+
+reveal_type(def_gen.shuffle(np.arange(10)))  # E: None
+reveal_type(def_gen.shuffle([1, 2, 3, 4, 5]))  # E: None
+reveal_type(def_gen.shuffle(D_2D, axis=1))  # E: None
+
+reveal_type(np.random.Generator(pcg64))  # E: Generator
+reveal_type(def_gen.__str__())  # E: str
+reveal_type(def_gen.__repr__())  # E: str
+def_gen_state = def_gen.__getstate__()
+reveal_type(def_gen_state)  # E: builtins.dict[builtins.str, Any]
+reveal_type(def_gen.__setstate__(def_gen_state))  # E: None
+
+# RandomState
+random_st: np.random.RandomState = np.random.RandomState()
+
+reveal_type(random_st.standard_normal())  # E: float
+reveal_type(random_st.standard_normal(size=None))  # E: float
+reveal_type(random_st.standard_normal(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(random_st.random())  # E: float
+reveal_type(random_st.random(size=None))  # E: float
+reveal_type(random_st.random(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(random_st.standard_cauchy())  # E: float
+reveal_type(random_st.standard_cauchy(size=None))  # E: float
+reveal_type(random_st.standard_cauchy(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.standard_exponential())  # E: float
+reveal_type(random_st.standard_exponential(size=None))  # E: float
+reveal_type(random_st.standard_exponential(size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(random_st.zipf(1.5))  # E: int
+reveal_type(random_st.zipf(1.5, size=None))  # E: int
+reveal_type(random_st.zipf(1.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.zipf(D_arr_1p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.zipf(D_arr_1p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.zipf(D_arr_like_1p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.zipf(D_arr_like_1p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.weibull(0.5))  # E: float
+reveal_type(random_st.weibull(0.5, size=None))  # E: float
+reveal_type(random_st.weibull(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.weibull(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.weibull(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.weibull(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.weibull(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.standard_t(0.5))  # E: float
+reveal_type(random_st.standard_t(0.5, size=None))  # E: float
+reveal_type(random_st.standard_t(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.standard_t(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.standard_t(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.standard_t(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.standard_t(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.poisson(0.5))  # E: int
+reveal_type(random_st.poisson(0.5, size=None))  # E: int
+reveal_type(random_st.poisson(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.poisson(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.poisson(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.poisson(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.poisson(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.power(0.5))  # E: float
+reveal_type(random_st.power(0.5, size=None))  # E: float
+reveal_type(random_st.power(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.power(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.power(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.power(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.power(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.pareto(0.5))  # E: float
+reveal_type(random_st.pareto(0.5, size=None))  # E: float
+reveal_type(random_st.pareto(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.pareto(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.pareto(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.pareto(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.pareto(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.chisquare(0.5))  # E: float
+reveal_type(random_st.chisquare(0.5, size=None))  # E: float
+reveal_type(random_st.chisquare(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.chisquare(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.chisquare(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.chisquare(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.chisquare(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.exponential(0.5))  # E: float
+reveal_type(random_st.exponential(0.5, size=None))  # E: float
+reveal_type(random_st.exponential(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.exponential(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.exponential(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.exponential(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.exponential(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.geometric(0.5))  # E: int
+reveal_type(random_st.geometric(0.5, size=None))  # E: int
+reveal_type(random_st.geometric(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.geometric(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.geometric(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.geometric(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.geometric(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.logseries(0.5))  # E: int
+reveal_type(random_st.logseries(0.5, size=None))  # E: int
+reveal_type(random_st.logseries(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.logseries(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.logseries(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.logseries(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.logseries(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.rayleigh(0.5))  # E: float
+reveal_type(random_st.rayleigh(0.5, size=None))  # E: float
+reveal_type(random_st.rayleigh(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.rayleigh(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.rayleigh(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.rayleigh(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.rayleigh(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.standard_gamma(0.5))  # E: float
+reveal_type(random_st.standard_gamma(0.5, size=None))  # E: float
+reveal_type(random_st.standard_gamma(0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(random_st.standard_gamma(D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(random_st.standard_gamma(D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(random_st.standard_gamma(D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(random_st.standard_gamma(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+reveal_type(random_st.standard_gamma(D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]]
+
+reveal_type(random_st.vonmises(0.5, 0.5))  # E: float
+reveal_type(random_st.vonmises(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.vonmises(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.vonmises(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.wald(0.5, 0.5))  # E: float
+reveal_type(random_st.wald(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.wald(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.wald(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.uniform(0.5, 0.5))  # E: float
+reveal_type(random_st.uniform(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.uniform(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.uniform(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.beta(0.5, 0.5))  # E: float
+reveal_type(random_st.beta(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.beta(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.beta(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.f(0.5, 0.5))  # E: float
+reveal_type(random_st.f(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.f(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.f(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.gamma(0.5, 0.5))  # E: float
+reveal_type(random_st.gamma(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.gamma(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gamma(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.gumbel(0.5, 0.5))  # E: float
+reveal_type(random_st.gumbel(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.gumbel(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.gumbel(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.laplace(0.5, 0.5))  # E: float
+reveal_type(random_st.laplace(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.laplace(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.laplace(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.logistic(0.5, 0.5))  # E: float
+reveal_type(random_st.logistic(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.logistic(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.logistic(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.lognormal(0.5, 0.5))  # E: float
+reveal_type(random_st.lognormal(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.lognormal(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.lognormal(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.noncentral_chisquare(0.5, 0.5))  # E: float
+reveal_type(random_st.noncentral_chisquare(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.noncentral_chisquare(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_chisquare(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.normal(0.5, 0.5))  # E: float
+reveal_type(random_st.normal(0.5, 0.5, size=None))  # E: float
+reveal_type(random_st.normal(0.5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(0.5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_0p5, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(0.5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_like_0p5, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(0.5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_0p5, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_like_0p5, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_0p5, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.normal(D_arr_like_0p5, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.triangular(0.1, 0.5, 0.9))  # E: float
+reveal_type(random_st.triangular(0.1, 0.5, 0.9, size=None))  # E: float
+reveal_type(random_st.triangular(0.1, 0.5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_0p1, 0.5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(0.1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_0p1, 0.5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(0.1, D_arr_0p5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_like_0p1, 0.5, D_arr_0p9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(0.5, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_0p1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.triangular(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.noncentral_f(0.1, 0.5, 0.9))  # E: float
+reveal_type(random_st.noncentral_f(0.1, 0.5, 0.9, size=None))  # E: float
+reveal_type(random_st.noncentral_f(0.1, 0.5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_0p1, 0.5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(0.1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_0p1, 0.5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(0.1, D_arr_0p5, 0.9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_like_0p1, 0.5, D_arr_0p9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(0.5, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_0p1, D_arr_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, 0.9))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_0p1, D_arr_0p5, D_arr_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.noncentral_f(D_arr_like_0p1, D_arr_like_0p5, D_arr_like_0p9, size=1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.binomial(10, 0.5))  # E: int
+reveal_type(random_st.binomial(10, 0.5, size=None))  # E: int
+reveal_type(random_st.binomial(10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_like_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_like_10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.binomial(I_arr_like_10, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.negative_binomial(10, 0.5))  # E: int
+reveal_type(random_st.negative_binomial(10, 0.5, size=None))  # E: int
+reveal_type(random_st.negative_binomial(10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_10, 0.5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_like_10, 0.5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_10, D_arr_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_10, D_arr_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.negative_binomial(I_arr_like_10, D_arr_like_0p5, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.hypergeometric(20, 20, 10))  # E: int
+reveal_type(random_st.hypergeometric(20, 20, 10, size=None))  # E: int
+reveal_type(random_st.hypergeometric(20, 20, 10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_20, 20, 10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(20, I_arr_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_20, 20, I_arr_like_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(20, I_arr_20, 10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_like_20, 20, I_arr_10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(20, I_arr_like_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_20, I_arr_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_like_20, I_arr_like_20, 10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_20, I_arr_20, I_arr_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.hypergeometric(I_arr_like_20, I_arr_like_20, I_arr_like_10, size=1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.randint(0, 100))  # E: int
+reveal_type(random_st.randint(100))  # E: int
+reveal_type(random_st.randint([100]))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.randint(0, [100]))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.randint(2, dtype=bool))  # E: builtins.bool
+reveal_type(random_st.randint(0, 2, dtype=bool))  # E: builtins.bool
+reveal_type(random_st.randint(I_bool_high_open, dtype=bool))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(random_st.randint(I_bool_low, I_bool_high_open, dtype=bool))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(random_st.randint(0, I_bool_high_open, dtype=bool))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+
+reveal_type(random_st.randint(2, dtype=np.bool_))  # E: builtins.bool
+reveal_type(random_st.randint(0, 2, dtype=np.bool_))  # E: builtins.bool
+reveal_type(random_st.randint(I_bool_high_open, dtype=np.bool_))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(random_st.randint(I_bool_low, I_bool_high_open, dtype=np.bool_))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+reveal_type(random_st.randint(0, I_bool_high_open, dtype=np.bool_))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]
+
+reveal_type(random_st.randint(256, dtype="u1"))  # E: int
+reveal_type(random_st.randint(0, 256, dtype="u1"))  # E: int
+reveal_type(random_st.randint(I_u1_high_open, dtype="u1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(I_u1_low, I_u1_high_open, dtype="u1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(0, I_u1_high_open, dtype="u1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+
+reveal_type(random_st.randint(256, dtype="uint8"))  # E: int
+reveal_type(random_st.randint(0, 256, dtype="uint8"))  # E: int
+reveal_type(random_st.randint(I_u1_high_open, dtype="uint8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(I_u1_low, I_u1_high_open, dtype="uint8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(0, I_u1_high_open, dtype="uint8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+
+reveal_type(random_st.randint(256, dtype=np.uint8))  # E: int
+reveal_type(random_st.randint(0, 256, dtype=np.uint8))  # E: int
+reveal_type(random_st.randint(I_u1_high_open, dtype=np.uint8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(I_u1_low, I_u1_high_open, dtype=np.uint8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(0, I_u1_high_open, dtype=np.uint8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._8Bit]]]
+
+reveal_type(random_st.randint(65536, dtype="u2"))  # E: int
+reveal_type(random_st.randint(0, 65536, dtype="u2"))  # E: int
+reveal_type(random_st.randint(I_u2_high_open, dtype="u2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(I_u2_low, I_u2_high_open, dtype="u2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(0, I_u2_high_open, dtype="u2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+
+reveal_type(random_st.randint(65536, dtype="uint16"))  # E: int
+reveal_type(random_st.randint(0, 65536, dtype="uint16"))  # E: int
+reveal_type(random_st.randint(I_u2_high_open, dtype="uint16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(I_u2_low, I_u2_high_open, dtype="uint16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(0, I_u2_high_open, dtype="uint16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+
+reveal_type(random_st.randint(65536, dtype=np.uint16))  # E: int
+reveal_type(random_st.randint(0, 65536, dtype=np.uint16))  # E: int
+reveal_type(random_st.randint(I_u2_high_open, dtype=np.uint16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(I_u2_low, I_u2_high_open, dtype=np.uint16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(0, I_u2_high_open, dtype=np.uint16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._16Bit]]]
+
+reveal_type(random_st.randint(4294967296, dtype="u4"))  # E: int
+reveal_type(random_st.randint(0, 4294967296, dtype="u4"))  # E: int
+reveal_type(random_st.randint(I_u4_high_open, dtype="u4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype="u4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(0, I_u4_high_open, dtype="u4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+
+reveal_type(random_st.randint(4294967296, dtype="uint32"))  # E: int
+reveal_type(random_st.randint(0, 4294967296, dtype="uint32"))  # E: int
+reveal_type(random_st.randint(I_u4_high_open, dtype="uint32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype="uint32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(0, I_u4_high_open, dtype="uint32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+
+reveal_type(random_st.randint(4294967296, dtype=np.uint32))  # E: int
+reveal_type(random_st.randint(0, 4294967296, dtype=np.uint32))  # E: int
+reveal_type(random_st.randint(I_u4_high_open, dtype=np.uint32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(0, I_u4_high_open, dtype=np.uint32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]]
+
+reveal_type(random_st.randint(4294967296, dtype=np.uint))  # E: int
+reveal_type(random_st.randint(0, 4294967296, dtype=np.uint))  # E: int
+reveal_type(random_st.randint(I_u4_high_open, dtype=np.uint))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(random_st.randint(I_u4_low, I_u4_high_open, dtype=np.uint))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+reveal_type(random_st.randint(0, I_u4_high_open, dtype=np.uint))  # E: numpy.ndarray[Any, numpy.dtype[{uint}]]
+
+reveal_type(random_st.randint(18446744073709551616, dtype="u8"))  # E: int
+reveal_type(random_st.randint(0, 18446744073709551616, dtype="u8"))  # E: int
+reveal_type(random_st.randint(I_u8_high_open, dtype="u8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(I_u8_low, I_u8_high_open, dtype="u8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(0, I_u8_high_open, dtype="u8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+
+reveal_type(random_st.randint(18446744073709551616, dtype="uint64"))  # E: int
+reveal_type(random_st.randint(0, 18446744073709551616, dtype="uint64"))  # E: int
+reveal_type(random_st.randint(I_u8_high_open, dtype="uint64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(I_u8_low, I_u8_high_open, dtype="uint64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(0, I_u8_high_open, dtype="uint64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+
+reveal_type(random_st.randint(18446744073709551616, dtype=np.uint64))  # E: int
+reveal_type(random_st.randint(0, 18446744073709551616, dtype=np.uint64))  # E: int
+reveal_type(random_st.randint(I_u8_high_open, dtype=np.uint64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(I_u8_low, I_u8_high_open, dtype=np.uint64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(0, I_u8_high_open, dtype=np.uint64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._64Bit]]]
+
+reveal_type(random_st.randint(128, dtype="i1"))  # E: int
+reveal_type(random_st.randint(-128, 128, dtype="i1"))  # E: int
+reveal_type(random_st.randint(I_i1_high_open, dtype="i1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(I_i1_low, I_i1_high_open, dtype="i1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(-128, I_i1_high_open, dtype="i1"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+
+reveal_type(random_st.randint(128, dtype="int8"))  # E: int
+reveal_type(random_st.randint(-128, 128, dtype="int8"))  # E: int
+reveal_type(random_st.randint(I_i1_high_open, dtype="int8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(I_i1_low, I_i1_high_open, dtype="int8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(-128, I_i1_high_open, dtype="int8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+
+reveal_type(random_st.randint(128, dtype=np.int8))  # E: int
+reveal_type(random_st.randint(-128, 128, dtype=np.int8))  # E: int
+reveal_type(random_st.randint(I_i1_high_open, dtype=np.int8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(I_i1_low, I_i1_high_open, dtype=np.int8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+reveal_type(random_st.randint(-128, I_i1_high_open, dtype=np.int8))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._8Bit]]]
+
+reveal_type(random_st.randint(32768, dtype="i2"))  # E: int
+reveal_type(random_st.randint(-32768, 32768, dtype="i2"))  # E: int
+reveal_type(random_st.randint(I_i2_high_open, dtype="i2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(I_i2_low, I_i2_high_open, dtype="i2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(-32768, I_i2_high_open, dtype="i2"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(32768, dtype="int16"))  # E: int
+reveal_type(random_st.randint(-32768, 32768, dtype="int16"))  # E: int
+reveal_type(random_st.randint(I_i2_high_open, dtype="int16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(I_i2_low, I_i2_high_open, dtype="int16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(-32768, I_i2_high_open, dtype="int16"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(32768, dtype=np.int16))  # E: int
+reveal_type(random_st.randint(-32768, 32768, dtype=np.int16))  # E: int
+reveal_type(random_st.randint(I_i2_high_open, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(I_i2_low, I_i2_high_open, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+reveal_type(random_st.randint(-32768, I_i2_high_open, dtype=np.int16))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._16Bit]]]
+
+reveal_type(random_st.randint(2147483648, dtype="i4"))  # E: int
+reveal_type(random_st.randint(-2147483648, 2147483648, dtype="i4"))  # E: int
+reveal_type(random_st.randint(I_i4_high_open, dtype="i4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype="i4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype="i4"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+
+reveal_type(random_st.randint(2147483648, dtype="int32"))  # E: int
+reveal_type(random_st.randint(-2147483648, 2147483648, dtype="int32"))  # E: int
+reveal_type(random_st.randint(I_i4_high_open, dtype="int32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype="int32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype="int32"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+
+reveal_type(random_st.randint(2147483648, dtype=np.int32))  # E: int
+reveal_type(random_st.randint(-2147483648, 2147483648, dtype=np.int32))  # E: int
+reveal_type(random_st.randint(I_i4_high_open, dtype=np.int32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype=np.int32))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._32Bit]]]
+
+reveal_type(random_st.randint(2147483648, dtype=np.int_))  # E: int
+reveal_type(random_st.randint(-2147483648, 2147483648, dtype=np.int_))  # E: int
+reveal_type(random_st.randint(I_i4_high_open, dtype=np.int_))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.randint(I_i4_low, I_i4_high_open, dtype=np.int_))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.randint(-2147483648, I_i4_high_open, dtype=np.int_))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.randint(9223372036854775808, dtype="i8"))  # E: int
+reveal_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype="i8"))  # E: int
+reveal_type(random_st.randint(I_i8_high_open, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(I_i8_low, I_i8_high_open, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype="i8"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(random_st.randint(9223372036854775808, dtype="int64"))  # E: int
+reveal_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype="int64"))  # E: int
+reveal_type(random_st.randint(I_i8_high_open, dtype="int64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(I_i8_low, I_i8_high_open, dtype="int64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype="int64"))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(random_st.randint(9223372036854775808, dtype=np.int64))  # E: int
+reveal_type(random_st.randint(-9223372036854775808, 9223372036854775808, dtype=np.int64))  # E: int
+reveal_type(random_st.randint(I_i8_high_open, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(I_i8_low, I_i8_high_open, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+reveal_type(random_st.randint(-9223372036854775808, I_i8_high_open, dtype=np.int64))  # E: numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[numpy.typing._64Bit]]]
+
+reveal_type(random_st._bit_generator)  # E: BitGenerator
+
+reveal_type(random_st.bytes(2))  # E: bytes
+
+reveal_type(random_st.choice(5))  # E: int
+reveal_type(random_st.choice(5, 3))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.choice(5, 3, replace=True))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.choice(5, 3, p=[1 / 5] * 5))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.choice(5, 3, p=[1 / 5] * 5, replace=False))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"]))  # E: Any
+reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3))  # E: numpy.ndarray[Any, Any]
+reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, p=[1 / 4] * 4))  # E: numpy.ndarray[Any, Any]
+reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=True))  # E: numpy.ndarray[Any, Any]
+reveal_type(random_st.choice(["pooh", "rabbit", "piglet", "Christopher"], 3, replace=False, p=np.array([1 / 8, 1 / 8, 1 / 2, 1 / 4])))  # E: numpy.ndarray[Any, Any]
+
+reveal_type(random_st.dirichlet([0.5, 0.5]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.dirichlet(np.array([0.5, 0.5])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.dirichlet(np.array([0.5, 0.5]), size=3))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.multinomial(20, [1 / 6.0] * 6))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.multinomial(20, np.array([0.5, 0.5])))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.multinomial(20, [1 / 6.0] * 6, size=2))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+
+reveal_type(random_st.multivariate_normal([0.0], [[1.0]]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.multivariate_normal([0.0], np.array([[1.0]])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.multivariate_normal(np.array([0.0]), [[1.0]]))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.multivariate_normal([0.0], np.array([[1.0]])))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.permutation(10))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.permutation([1, 2, 3, 4]))  # E: numpy.ndarray[Any, Any]
+reveal_type(random_st.permutation(np.array([1, 2, 3, 4])))  # E: numpy.ndarray[Any, Any]
+reveal_type(random_st.permutation(D_2D))  # E: numpy.ndarray[Any, Any]
+
+reveal_type(random_st.shuffle(np.arange(10)))  # E: None
+reveal_type(random_st.shuffle([1, 2, 3, 4, 5]))  # E: None
+reveal_type(random_st.shuffle(D_2D))  # E: None
+
+reveal_type(np.random.RandomState(pcg64))  # E: RandomState
+reveal_type(np.random.RandomState(0))  # E: RandomState
+reveal_type(np.random.RandomState([0, 1, 2]))  # E: RandomState
+reveal_type(random_st.__str__())  # E: str
+reveal_type(random_st.__repr__())  # E: str
+random_st_state = random_st.__getstate__()
+reveal_type(random_st_state)  # E: builtins.dict[builtins.str, Any]
+reveal_type(random_st.__setstate__(random_st_state))  # E: None
+reveal_type(random_st.seed())  # E: None
+reveal_type(random_st.seed(1))  # E: None
+reveal_type(random_st.seed([0, 1]))  # E: None
+random_st_get_state = random_st.get_state()
+reveal_type(random_st_state)  # E: builtins.dict[builtins.str, Any]
+random_st_get_state_legacy = random_st.get_state(legacy=True)
+reveal_type(random_st_get_state_legacy)  # E: Union[builtins.dict[builtins.str, Any], Tuple[builtins.str, numpy.ndarray[Any, numpy.dtype[numpy.unsignedinteger[numpy.typing._32Bit]]], builtins.int, builtins.int, builtins.float]]
+reveal_type(random_st.set_state(random_st_get_state))  # E: None
+
+reveal_type(random_st.rand())  # E: float
+reveal_type(random_st.rand(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.rand(1, 2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.randn())  # E: float
+reveal_type(random_st.randn(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.randn(1, 2))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.random_sample())  # E: float
+reveal_type(random_st.random_sample(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+reveal_type(random_st.random_sample(size=(1, 2)))  # E: numpy.ndarray[Any, numpy.dtype[numpy.floating[numpy.typing._64Bit]]
+
+reveal_type(random_st.tomaxint())  # E: int
+reveal_type(random_st.tomaxint(1))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
+reveal_type(random_st.tomaxint((1,)))  # E: numpy.ndarray[Any, numpy.dtype[{int_}]]
diff --git a/numpy/typing/tests/test_typing.py b/numpy/typing/tests/test_typing.py
index e80282420..70355dcd9 100644
--- a/numpy/typing/tests/test_typing.py
+++ b/numpy/typing/tests/test_typing.py
@@ -48,8 +48,11 @@ def run_mypy() -> None:
 
     The mypy results are cached in `OUTPUT_MYPY` for further use.
 
+    The cache refresh can be skipped using
+
+    NUMPY_TYPING_TEST_CLEAR_CACHE=0 pytest numpy/typing/tests
     """
-    if os.path.isdir(CACHE_DIR):
+    if os.path.isdir(CACHE_DIR) and bool(os.environ.get("NUMPY_TYPING_TEST_CLEAR_CACHE", True)):
         shutil.rmtree(CACHE_DIR)
 
     for directory in (PASS_DIR, REVEAL_DIR, FAIL_DIR, MISC_DIR):