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

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

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

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

{-# 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.Double;

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Test.QuickCheck.Arbitrary ();

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

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

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

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

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

{-# NEED #-}
instance Test.QuickCheck.Testable Test.QuickCheck.Result;

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

{-# NEED #-}
instance Test.QuickCheck.Testable Test.QuickCheck.Property;

{-# NEED #-}
instance Test.QuickCheck.Testable ();

{-# NEED #-}
instance (Test.QuickCheck.Arbitrary a,Prelude.Show a,Test.QuickCheck.Testable b) => Test.QuickCheck.Testable (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 System.Random.StdGen;

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

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

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

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

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

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (Ratio.Ratio a);
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface Ratio
{-# NEED Ratio #-}
data (Prelude.Integral a) => Ratio a;
interface ! Test.QuickCheck
{-# NEED sized #-}
sized{-# 1 #-}::((Prelude.Int -> (Test.QuickCheck.Gen a)) -> (Test.QuickCheck.Gen a));

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

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

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

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

{-# NEED generate #-}
generate{-# 3 #-}::(Prelude.Int -> (System.Random.StdGen -> ((Test.QuickCheck.Gen a) -> a)));

{-# NEED choose #-}
choose{-# 1 #-}::(System.Random.Random a) => ((a,a) -> (Test.QuickCheck.Gen a));
interface System.Random
{-# NEED Random #-}
class Random a;
interface ! Test.QuickCheck
{-# NEED elements #-}
elements{-# 1 #-}::([a] -> (Test.QuickCheck.Gen a));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED defaultConfig #-}
defaultConfig{-# 0 #-}::Test.QuickCheck.Config;

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

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

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

{-# NEED check #-}
check{-# 2 #-}::(Test.QuickCheck.Testable a) => (Test.QuickCheck.Config -> (a -> (NHC.Internal.IO ())));
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

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

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

{-# NEED {Property} #-}
newtype {-#  #-} Property
  = Unexported.Constr_39 (Test.QuickCheck.Gen Test.QuickCheck.Result);

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

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