interface Random where {

{-# NEED #-}
instance Random Prelude.Bool;

{-# NEED #-}
instance Random Prelude.Integer;

{-# NEED #-}
instance Random Prelude.Float;

{-# NEED #-}
instance Random Prelude.Double;

{-# NEED #-}
instance Random Prelude.Int;

{-# NEED #-}
instance Random Prelude.Char;

{-# NEED #-}
instance RandomGen StdGen;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Fractional (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Word64;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Word32;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Word16;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Word8;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Int64;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Int32;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Int16;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Int8;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.ForeignObj;

{-# NEED #-}
instance Prelude.NmCoerce (FFIBuiltin.StablePtr a);

{-# NEED #-}
instance Prelude.NmCoerce PackedString.PackedString;

{-# NEED #-}
instance Prelude.NmCoerce FFIBuiltin.Addr;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Num (Ratio.Ratio a);

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Real (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Enum FFIBuiltin.Addr;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Enum (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Ord PackedString.PackedString;

{-# NEED #-}
instance Prelude.Ord FFIBuiltin.Addr;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Ord (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Eq PackedString.PackedString;

{-# NEED #-}
instance Prelude.Eq FFIBuiltin.Addr;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Eq (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Show StdGen;

{-# NEED #-}
instance Prelude.Show PackedString.PackedString;

{-# NEED #-}
instance Prelude.Show FFIBuiltin.Addr;

{-# NEED #-}
instance (Prelude.Integral a) => Prelude.Show (Ratio.Ratio a);

{-# NEED #-}
instance Prelude.Read StdGen;

{-# NEED #-}
instance Prelude.Read PackedString.PackedString;

{-# NEED #-}
instance (Prelude.Read a,Prelude.Integral a) => Prelude.Read (Ratio.Ratio a);
interface FFIBuiltin
{-# NEED Word64 #-}
data Word64;

{-# NEED Word32 #-}
data Word32;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word8 #-}
data Word8;

{-# NEED Int64 #-}
data Int64;

{-# NEED Int32 #-}
data Int32;

{-# NEED Int16 #-}
data Int16;

{-# NEED Int8 #-}
data Int8;

{-# NEED ForeignObj #-}
data ForeignObj;

{-# NEED StablePtr #-}
data StablePtr a;

{-# NEED Addr #-}
data Addr;
interface PackedString
{-# NEED PackedString #-}
data PackedString;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Random
{-# NEED getStdRandom #-}
getStdRandom{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (Prelude.Trace -> ((Prelude.R StdGen) -> (Prelude.R (a,StdGen))))) -> (Prelude.R (Prelude.IO a)))))));

{-# NEED newStdGen #-}
newStdGen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO StdGen))));

{-# NEED getStdGen #-}
getStdGen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO StdGen))));

{-# NEED setStdGen #-}
setStdGen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R StdGen) -> (Prelude.R (Prelude.IO ())))))));

{-# NEED {Random randoms randomRs randomIO randomRIO random randomR} #-}
class Random a where {
  randoms{-# 2 #-}::(RandomGen b) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R b) -> (Prelude.R [a]))))));
  randomRs{-# 2 #-}::(RandomGen b) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (a,a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R b) -> (Prelude.R [a])))))))));
  randomIO{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.IO a))));
  randomRIO{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (a,a)) -> (Prelude.R (Prelude.IO a)))))));
  random{-# 2 #-}::(RandomGen b) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R b) -> (Prelude.R (a,b)))))));
  randomR{-# 2 #-}::(RandomGen b) => (Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R (a,a)) -> (Prelude.R (Prelude.Trace -> ((Prelude.R b) -> (Prelude.R (a,b))))))))));
};

{-# NEED mkStdGen #-}
mkStdGen{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R Prelude.Int) -> (Prelude.R StdGen))))));

{-# NEED StdGen #-}
data StdGen;

{-# NEED {RandomGen genRange next split} #-}
class RandomGen a where {
  genRange{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.Int,Prelude.Int)))))));
  next{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (Prelude.Int,a)))))));
  split{-# 2 #-}::(Prelude.SR -> (Prelude.Trace -> (Prelude.R (Prelude.Trace -> ((Prelude.R a) -> (Prelude.R (a,a)))))));
};
}
