interface Test.QuickCheck where {
infix   1 `classify`;
infixr  0 ==>;

{-# NEED #-}
instance Data.Typeable.Typeable1 Ratio.Ratio;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.Internal.IO;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Ratio.Ratio a);

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.Internal.IO a);

{-# NEED #-}
instance Testable Property;

{-# NEED #-}
instance Testable Result;

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

{-# NEED #-}
instance Testable ();

{-# NEED #-}
instance (Arbitrary a,Prelude.Show a,Testable b) => Testable (a -> b);

{-# NEED #-}
instance (Arbitrary a,Arbitrary b,Arbitrary c) => Arbitrary (a,b,c);

{-# NEED #-}
instance (Arbitrary a,Arbitrary b,Arbitrary c,Arbitrary d) => Arbitrary (a,b,c,d);

{-# NEED #-}
instance (Arbitrary a) => Arbitrary (Prelude.Maybe a);

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

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

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

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

{-# NEED #-}
instance (Arbitrary a,Arbitrary b) => Arbitrary (Prelude.Either a b);

{-# NEED #-}
instance Arbitrary ();

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

{-# NEED #-}
instance (Arbitrary a) => Arbitrary [a];

{-# NEED #-}
instance (Arbitrary a,Arbitrary b) => Arbitrary (a,b);

{-# NEED #-}
instance (Arbitrary a,Arbitrary b) => Arbitrary (a -> b);

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Functor Gen;

{-# NEED #-}
instance Prelude.Functor NHC.Internal.IO;

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

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (NHC.Internal.IO a);

{-# NEED #-}
instance System.Random.RandomGen System.Random.StdGen;

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Monad Gen;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;
interface Data.Typeable
{-# NEED #-}
class Typeable a;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Test.QuickCheck
{-# NEED check #-}
check{-# 2 #-}::(Testable a) => (Config -> (a -> (NHC.Internal.IO ())));

{-# NEED verboseCheck #-}
verboseCheck{-# 0 #-}::(Testable a) => (a -> (NHC.Internal.IO ()));

{-# NEED quickCheck #-}
quickCheck{-# 0 #-}::(Testable a) => (a -> (NHC.Internal.IO ()));

{-# NEED test #-}
test{-# 0 #-}::(Testable a) => (a -> (NHC.Internal.IO ()));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Test.QuickCheck
{-# NEED defaultConfig #-}
defaultConfig{-# 0 #-}::Config;

{-# NEED {Config Config configMaxTest configMaxFail configSize configEvery} #-}
data Config
  = Config {configMaxTest :: Prelude.Int} {configMaxFail :: Prelude.Int} {configSize :: (Prelude.Int -> Prelude.Int)} {configEvery :: (Prelude.Int -> ([Prelude.String] -> Prelude.String))};

{-# NEED collect #-}
collect{-# 1 #-}::(Prelude.Show a,Testable b) => (a -> (b -> Property));

{-# NEED trivial #-}
trivial{-# 0 #-}::(Testable a) => (Prelude.Bool -> (a -> Property));

{-# NEED classify #-}
classify{-# 2 #-}::(Testable a) => (Prelude.Bool -> (Prelude.String -> (a -> Property)));

{-# NEED label #-}
label{-# 2 #-}::(Testable a) => (Prelude.String -> (a -> Property));

{-# NEED (==>) #-}
(==>){-# 2 #-}::(Testable a) => (Prelude.Bool -> (a -> Property));

{-# NEED forAll #-}
forAll{-# 2 #-}::(Prelude.Show a,Testable b) => ((Gen a) -> ((a -> b) -> Property));

{-# NEED evaluate #-}
evaluate{-# 1 #-}::(Testable a) => (a -> (Gen Result));

{-# NEED {Testable property} #-}
class Testable a where {
  property{-# 1 #-}::(a -> Property);
};

{-# NEED {Property} #-}
newtype {-#  #-} Property
  = Prop (Gen Result);

{-# NEED {Result Result ok stamp arguments} #-}
data Result
  = Result {ok :: (Prelude.Maybe Prelude.Bool)} {stamp :: [Prelude.String]} {arguments :: [Prelude.String]};

{-# NEED four #-}
four{-# 1 #-}::(Prelude.Monad a) => ((a b) -> (a (b,b,b,b)));

{-# NEED three #-}
three{-# 1 #-}::(Prelude.Monad a) => ((a b) -> (a (b,b,b)));

{-# NEED two #-}
two{-# 1 #-}::(Prelude.Monad a) => ((a b) -> (a (b,b)));

{-# NEED frequency #-}
frequency{-# 1 #-}::([(Prelude.Int,(Gen a))] -> (Gen a));

{-# NEED oneof #-}
oneof{-# 1 #-}::([(Gen a)] -> (Gen a));

{-# NEED vector #-}
vector{-# 1 #-}::(Arbitrary a) => (Prelude.Int -> (Gen [a]));

{-# NEED {Arbitrary arbitrary coarbitrary} #-}
class Arbitrary a where {
  arbitrary{-# 0 #-}::(Gen a);
  coarbitrary{-# 2 #-}::(a -> ((Gen b) -> (Gen b)));
};

{-# NEED elements #-}
elements{-# 1 #-}::([a] -> (Gen a));

{-# NEED choose #-}
choose{-# 1 #-}::(System.Random.Random a) => ((a,a) -> (Gen a));
interface System.Random
{-# NEED Random #-}
class Random a;
interface ! Test.QuickCheck
{-# NEED generate #-}
generate{-# 3 #-}::(Prelude.Int -> (System.Random.StdGen -> ((Gen a) -> a)));

{-# NEED variant #-}
variant{-# 2 #-}::(Prelude.Int -> ((Gen a) -> (Gen a)));

{-# NEED promote #-}
promote{-# 1 #-}::((a -> (Gen b)) -> (Gen (a -> b)));

{-# NEED rand #-}
rand{-# 0 #-}::(Gen System.Random.StdGen);

{-# NEED resize #-}
resize{-# 2 #-}::(Prelude.Int -> ((Gen a) -> (Gen a)));

{-# NEED sized #-}
sized{-# 1 #-}::((Prelude.Int -> (Gen a)) -> (Gen a));

{-# NEED {Gen} #-}
newtype {-#  #-} Gen a
  = Gen (Prelude.Int -> (System.Random.StdGen -> a));
interface System.Random
{-# NEED StdGen #-}
data StdGen;
}