interface Data.Tree where {

{-# NEED #-}
instance (Control.Monad.Fix.MonadFix a) => Control.Arrow.ArrowLoop (Control.Arrow.Kleisli a);

{-# NEED #-}
instance (Prelude.Monad a) => Control.Arrow.ArrowChoice (Control.Arrow.Kleisli a);

{-# NEED #-}
instance (Data.Sequence.Sized a) => Data.Sequence.Sized (Data.Sequence.FingerTree a);

{-# NEED #-}
instance (Data.Sequence.Sized a) => Data.Sequence.Sized (Data.Sequence.Digit a);

{-# NEED #-}
instance Data.Sequence.Sized (Data.Sequence.Node a);

{-# NEED #-}
instance Data.Sequence.Sized (Data.Sequence.Elem a);

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word64;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word32;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word16;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Word8;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int8;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int16;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int32;

{-# NEED #-}
instance Data.Bits.Bits NHC.FFI.Int64;

{-# NEED #-}
instance NHC.FFI.Storable (NHC.FFI.StablePtr a);

{-# NEED #-}
instance NHC.FFI.Storable (NHC.FFI.Ptr a);

{-# NEED #-}
instance NHC.FFI.Storable (NHC.FFI.FunPtr a);

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word64;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word32;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word16;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Word8;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int8;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int16;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int32;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.Int64;

{-# NEED #-}
instance NHC.FFI.Storable NHC.FFI.CInt;

{-# NEED #-}
instance Control.Monad.Fix.MonadFix Prelude.Maybe;

{-# NEED #-}
instance Control.Monad.Fix.MonadFix Prelude.[];

{-# NEED #-}
instance Control.Monad.Fix.MonadFix NHC.Internal.IO;

{-# NEED #-}
instance Control.Monad.Fix.MonadFix ( (->) a);

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

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

{-# NEED #-}
instance Data.Traversable.Traversable Tree;

{-# NEED #-}
instance (Ix.Ix a) => Data.Traversable.Traversable (Array.Array a);

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.FingerTree;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Digit;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Node;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Elem;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.ViewL;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.ViewR;

{-# NEED #-}
instance Data.Traversable.Traversable Prelude.Maybe;

{-# NEED #-}
instance Data.Traversable.Traversable Data.Sequence.Seq;

{-# NEED #-}
instance Data.Traversable.Traversable Prelude.[];

{-# NEED #-}
instance Data.Typeable.Typeable2 Prelude.Either;

{-# NEED #-}
instance Data.Typeable.Typeable2 Array.Array;

{-# NEED #-}
instance Data.Typeable.Typeable2 (Prelude.Monad a);

{-# NEED #-}
instance Data.Foldable.Foldable Tree;

{-# NEED #-}
instance (Ix.Ix a) => Data.Foldable.Foldable (Array.Array a);

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.FingerTree;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Digit;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Node;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Elem;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.ViewL;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.ViewR;

{-# NEED #-}
instance Data.Foldable.Foldable Prelude.Maybe;

{-# NEED #-}
instance Data.Foldable.Foldable Data.Sequence.Seq;

{-# NEED #-}
instance Data.Foldable.Foldable Prelude.[];

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

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.StablePtr;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.IOExtras.IORef;

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable1 (Prelude.Either a);

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

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.Ptr;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.ForeignPtr;

{-# NEED #-}
instance Data.Typeable.Typeable1 NHC.FFI.FunPtr;

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

{-# NEED #-}
instance Data.Typeable.Typeable1 Data.Sequence.ViewL;

{-# NEED #-}
instance Data.Typeable.Typeable1 Data.Sequence.ViewR;

{-# NEED #-}
instance Data.Typeable.Typeable1 Prelude.Maybe;

{-# NEED #-}
instance Data.Typeable.Typeable1 Data.Sequence.Seq;

{-# NEED #-}
instance Data.Typeable.Typeable1 Prelude.[];

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Double;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Float;

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Bool;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Int;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Integer;

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Char;

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

{-# NEED #-}
instance Data.Typeable.Typeable Data.Typeable.TypeRep;

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable Data.Typeable.TyCon;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word64;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word32;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word16;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Word8;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int8;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int16;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int32;

{-# NEED #-}
instance Data.Typeable.Typeable NHC.FFI.Int64;

{-# NEED #-}
instance Data.Typeable.Typeable IO.Handle;

{-# NEED #-}
instance (Data.Typeable.Typeable a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (Array.Array a b);

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

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

{-# NEED #-}
instance Data.Typeable.Typeable Prelude.Ordering;

{-# NEED #-}
instance Data.Typeable.Typeable ();

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Real NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Real NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Bounded NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Bounded Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Bounded IO.IOMode;

{-# NEED #-}
instance Prelude.Bounded IO.SeekMode;

{-# NEED #-}
instance (Prelude.Bounded a) => Prelude.Bounded (Data.Monoid.Dual a);

{-# NEED #-}
instance Prelude.Bounded Data.Monoid.All;

{-# NEED #-}
instance Prelude.Bounded Data.Monoid.Any;

{-# NEED #-}
instance (Prelude.Bounded a) => Prelude.Bounded (Data.Monoid.Sum a);

{-# NEED #-}
instance (Prelude.Bounded a) => Prelude.Bounded (Data.Monoid.Product a);

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

{-# NEED #-}
instance Prelude.Ord (NHC.FFI.Ptr a);

{-# NEED #-}
instance Prelude.Ord (NHC.FFI.ForeignPtr a);

{-# NEED #-}
instance Prelude.Ord (NHC.FFI.FunPtr a);

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Ord NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Ord Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Ord IO.IOMode;

{-# NEED #-}
instance Prelude.Ord IO.SeekMode;

{-# NEED #-}
instance Prelude.Ord IO.BufferMode;

{-# NEED #-}
instance (Ix.Ix a,Prelude.Ord b) => Prelude.Ord (Array.Array a b);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Sequence.ViewL a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Monoid.Dual a);

{-# NEED #-}
instance Prelude.Ord Data.Monoid.All;

{-# NEED #-}
instance Prelude.Ord Data.Monoid.Any;

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Monoid.Sum a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Ord a) => Prelude.Ord (Data.Sequence.Seq a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Tree a);

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

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Read NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Read NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Read Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Read IO.IOMode;

{-# NEED #-}
instance Prelude.Read IO.SeekMode;

{-# NEED #-}
instance Prelude.Read IO.BufferMode;

{-# NEED #-}
instance (Ix.Ix a,Prelude.Read a,Prelude.Read b) => Prelude.Read (Array.Array a b);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Sequence.ViewL a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Monoid.Dual a);

{-# NEED #-}
instance Prelude.Read Data.Monoid.All;

{-# NEED #-}
instance Prelude.Read Data.Monoid.Any;

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Monoid.Sum a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Read a) => Prelude.Read (Data.Sequence.Seq a);

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

{-# NEED #-}
instance Prelude.Enum (NHC.FFI.Ptr a);

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Enum NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Enum Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Enum IO.IOMode;

{-# NEED #-}
instance Prelude.Enum IO.SeekMode;

{-# NEED #-}
instance Prelude.Enum DErrNo.ErrNo;

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

{-# NEED #-}
instance Prelude.Eq Data.HashTable.Inserts;

{-# NEED #-}
instance Prelude.Eq Data.Typeable.Key;

{-# NEED #-}
instance Prelude.Eq Data.Typeable.KeyPr;

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

{-# NEED #-}
instance Prelude.Eq Data.Typeable.TypeRep;

{-# NEED #-}
instance Prelude.Eq (NHC.FFI.Ptr a);

{-# NEED #-}
instance Prelude.Eq (NHC.FFI.ForeignPtr a);

{-# NEED #-}
instance Prelude.Eq (NHC.FFI.FunPtr a);

{-# NEED #-}
instance Prelude.Eq Data.Typeable.TyCon;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Eq IO.Handle;

{-# NEED #-}
instance Prelude.Eq NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Eq Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Eq IO.IOMode;

{-# NEED #-}
instance Prelude.Eq IO.SeekMode;

{-# NEED #-}
instance Prelude.Eq IO.BufferMode;

{-# NEED #-}
instance Prelude.Eq DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Eq Data.HashTable.HashData;

{-# NEED #-}
instance Prelude.Eq IO.HandlePosn;

{-# NEED #-}
instance (Ix.Ix a,Prelude.Eq b) => Prelude.Eq (Array.Array a b);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Sequence.ViewL a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Monoid.Dual a);

{-# NEED #-}
instance Prelude.Eq Data.Monoid.All;

{-# NEED #-}
instance Prelude.Eq Data.Monoid.Any;

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Monoid.Sum a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Eq a) => Prelude.Eq (Data.Sequence.Seq a);

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.Maybe;

{-# NEED #-}
instance Control.Monad.MonadPlus Data.Sequence.Seq;

{-# NEED #-}
instance Control.Monad.MonadPlus Prelude.[];

{-# NEED #-}
instance (Control.Monad.MonadPlus a) => Control.Applicative.Alternative (Control.Applicative.WrappedMonad a);

{-# NEED #-}
instance (Control.Arrow.ArrowZero a,Control.Arrow.ArrowPlus a) => Control.Applicative.Alternative (Control.Applicative.WrappedArrow a b);

{-# NEED #-}
instance Control.Applicative.Alternative Prelude.Maybe;

{-# NEED #-}
instance Control.Applicative.Alternative Prelude.[];

{-# NEED #-}
instance (Control.Monad.MonadPlus a) => Control.Arrow.ArrowPlus (Control.Arrow.Kleisli a);

{-# NEED #-}
instance (Control.Monad.MonadPlus a) => Control.Arrow.ArrowZero (Control.Arrow.Kleisli a);

{-# NEED #-}
instance Control.Applicative.Applicative Tree;

{-# NEED #-}
instance (Data.Monoid.Monoid a) => Control.Applicative.Applicative (Control.Applicative.Const a);

{-# NEED #-}
instance (Prelude.Monad a) => Control.Applicative.Applicative (Control.Applicative.WrappedMonad a);

{-# NEED #-}
instance (Control.Arrow.Arrow a) => Control.Applicative.Applicative (Control.Applicative.WrappedArrow a b);

{-# NEED #-}
instance Control.Applicative.Applicative Control.Applicative.ZipList;

{-# NEED #-}
instance Control.Applicative.Applicative Data.Traversable.Id;

{-# NEED #-}
instance (Data.Monoid.Monoid a) => Control.Applicative.Applicative ((,) a);

{-# NEED #-}
instance Control.Applicative.Applicative Prelude.Maybe;

{-# NEED #-}
instance Control.Applicative.Applicative Prelude.[];

{-# NEED #-}
instance Control.Applicative.Applicative NHC.Internal.IO;

{-# NEED #-}
instance Control.Applicative.Applicative ( (->) a);

{-# NEED #-}
instance (Prelude.Monad a) => Control.Arrow.ArrowApply (Control.Arrow.Kleisli a);

{-# NEED #-}
instance Control.Arrow.ArrowApply ( (->) a);

{-# NEED #-}
instance Control.Arrow.ArrowApply (Prelude.Monad a);

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Integral NHC.FFI.CInt;

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

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m,Ix.Ix n,Ix.Ix o) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l,Ix.Ix m) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l,m);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k,Ix.Ix l) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k,l);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j,Ix.Ix k) => Ix.Ix (a,b,c,d,e,f,g,h,i,j,k);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i,Ix.Ix j) => Ix.Ix (a,b,c,d,e,f,g,h,i,j);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h,Ix.Ix i) => Ix.Ix (a,b,c,d,e,f,g,h,i);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g,Ix.Ix h) => Ix.Ix (a,b,c,d,e,f,g,h);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f,Ix.Ix g) => Ix.Ix (a,b,c,d,e,f,g);

{-# NEED #-}
instance (Ix.Ix a,Ix.Ix b,Ix.Ix c,Ix.Ix d,Ix.Ix e,Ix.Ix f) => Ix.Ix (a,b,c,d,e,f);

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

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

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

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word64;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word32;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word16;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Word8;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int8;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int16;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int32;

{-# NEED #-}
instance Ix.Ix NHC.FFI.Int64;

{-# NEED #-}
instance Ix.Ix Data.Char.GeneralCategory;

{-# NEED #-}
instance Ix.Ix IO.IOMode;

{-# NEED #-}
instance Ix.Ix IO.SeekMode;

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

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

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

{-# NEED #-}
instance Ix.Ix Prelude.Ordering;

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

{-# NEED #-}
instance (Prelude.Monad a) => Control.Arrow.Arrow (Control.Arrow.Kleisli a);

{-# NEED #-}
instance Control.Arrow.Arrow ( (->) a);

{-# NEED #-}
instance Control.Arrow.Arrow (Prelude.Monad a);

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

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Num NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Num NHC.FFI.CInt;

{-# NEED #-}
instance (Data.Monoid.Monoid a,Data.Monoid.Monoid b,Data.Monoid.Monoid c) => Data.Monoid.Monoid (a,b,c);

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

{-# NEED #-}
instance (Data.Monoid.Monoid a,Data.Monoid.Monoid b,Data.Monoid.Monoid c,Data.Monoid.Monoid d,Data.Monoid.Monoid e) => Data.Monoid.Monoid (a,b,c,d,e);

{-# NEED #-}
instance Data.Monoid.Monoid Prelude.Ordering;

{-# NEED #-}
instance Data.Monoid.Monoid ();

{-# NEED #-}
instance (Data.Monoid.Monoid a,Data.Monoid.Monoid b) => Data.Monoid.Monoid (a,b);

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

{-# NEED #-}
instance (Data.Monoid.Monoid a) => Data.Monoid.Monoid (Data.Monoid.Dual a);

{-# NEED #-}
instance Data.Monoid.Monoid (Data.Monoid.Endo a);

{-# NEED #-}
instance Data.Monoid.Monoid Data.Monoid.All;

{-# NEED #-}
instance Data.Monoid.Monoid Data.Monoid.Any;

{-# NEED #-}
instance (Prelude.Num a) => Data.Monoid.Monoid (Data.Monoid.Sum a);

{-# NEED #-}
instance (Prelude.Num a) => Data.Monoid.Monoid (Data.Monoid.Product a);

{-# NEED #-}
instance Data.Monoid.Monoid (Data.Sequence.Seq a);

{-# NEED #-}
instance Data.Monoid.Monoid [a];

{-# NEED #-}
instance (Data.Monoid.Monoid b) => Data.Monoid.Monoid (a -> b);

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

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

{-# NEED #-}
instance Prelude.Show Data.Typeable.TypeRep;

{-# NEED #-}
instance Prelude.Show (NHC.FFI.Ptr a);

{-# NEED #-}
instance Prelude.Show (NHC.FFI.ForeignPtr a);

{-# NEED #-}
instance Prelude.Show (NHC.FFI.FunPtr a);

{-# NEED #-}
instance Prelude.Show Data.Typeable.TyCon;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word64;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word32;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word16;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Word8;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int8;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int16;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int32;

{-# NEED #-}
instance Prelude.Show NHC.FFI.Int64;

{-# NEED #-}
instance Prelude.Show IO.Handle;

{-# NEED #-}
instance Prelude.Show NHC.FFI.CInt;

{-# NEED #-}
instance Prelude.Show Data.Char.GeneralCategory;

{-# NEED #-}
instance Prelude.Show IO.IOMode;

{-# NEED #-}
instance Prelude.Show IO.SeekMode;

{-# NEED #-}
instance Prelude.Show IO.BufferMode;

{-# NEED #-}
instance Prelude.Show DErrNo.ErrNo;

{-# NEED #-}
instance Prelude.Show Data.HashTable.HashData;

{-# NEED #-}
instance Prelude.Show IO.HandlePosn;

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

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Sequence.ViewL a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Sequence.ViewR a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Monoid.Dual a);

{-# NEED #-}
instance Prelude.Show Data.Monoid.All;

{-# NEED #-}
instance Prelude.Show Data.Monoid.Any;

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Monoid.Sum a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Monoid.Product a);

{-# NEED #-}
instance (Prelude.Show a) => Prelude.Show (Data.Sequence.Seq a);

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

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

{-# NEED #-}
instance (Ix.Ix a) => Prelude.Functor (Array.Array a);

{-# NEED #-}
instance Prelude.Functor (Control.Applicative.Const a);

{-# NEED #-}
instance (Prelude.Monad a) => Prelude.Functor (Control.Applicative.WrappedMonad a);

{-# NEED #-}
instance (Control.Arrow.Arrow a) => Prelude.Functor (Control.Applicative.WrappedArrow a b);

{-# NEED #-}
instance Prelude.Functor Control.Applicative.ZipList;

{-# NEED #-}
instance Prelude.Functor Data.Traversable.Id;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.FingerTree;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Digit;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Node;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Elem;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.ViewL;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.ViewR;

{-# NEED #-}
instance Prelude.Functor Data.Sequence.Seq;

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

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

{-# NEED #-}
instance (Control.Arrow.ArrowApply a) => Prelude.Monad (Control.Arrow.ArrowMonad a);

{-# NEED #-}
instance Prelude.Monad Data.Sequence.Seq;

{-# NEED #-}
instance Prelude.Monad NHC.Internal.IO;
interface Control.Monad.Fix
{-# NEED MonadFix #-}
class (Prelude.Monad a) => MonadFix a;
interface Data.Sequence
{-# NEED #-}
class Sized a;
interface NHC.FFI
{-# NEED StablePtr #-}
data StablePtr a;
interface NHC.IOExtras
{-# NEED IORef #-}
newtype {-#  #-} IORef a;
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface Data.HashTable
{-# NEED Inserts #-}
data Inserts;
interface Data.Typeable
{-# NEED Key #-}
newtype {-#  #-} Key;

{-# NEED KeyPr #-}
data KeyPr;
interface Control.Arrow
{-# NEED ArrowPlus #-}
class (Control.Arrow.ArrowZero a) => ArrowPlus a;

{-# NEED ArrowZero #-}
class (Control.Arrow.Arrow a) => ArrowZero a;
interface Control.Monad
{-# NEED MonadPlus #-}
class (Prelude.Monad a) => MonadPlus a;
interface Control.Arrow
{-# NEED Kleisli #-}
newtype {-#  #-} Kleisli a b c;
interface Data.Monoid
{-# NEED Endo #-}
newtype {-#  #-} Endo a;

{-# NEED Monoid #-}
class Monoid a;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;
interface NHC.FFI
{-# NEED Ptr #-}
data Ptr a;

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

{-# NEED FunPtr #-}
data FunPtr a;
interface Data.Typeable
{-# NEED TyCon #-}
data TyCon;
interface NHC.FFI
{-# NEED Word64 #-}
data Word64;

{-# NEED Word32 #-}
data Word32;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word8 #-}
data Word8;

{-# NEED Int8 #-}
data Int8;

{-# NEED Int16 #-}
data Int16;

{-# NEED Int32 #-}
data Int32;

{-# NEED Int64 #-}
data Int64;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.FFI
{-# NEED CInt #-}
newtype {-#  #-} CInt;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface IO
{-# NEED IOMode #-}
data IOMode;

{-# NEED SeekMode #-}
data SeekMode;

{-# NEED BufferMode #-}
data BufferMode;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface Data.Monoid
{-# NEED Dual #-}
newtype {-#  #-} Dual a;

{-# NEED All #-}
newtype {-#  #-} All;

{-# NEED Any #-}
newtype {-#  #-} Any;

{-# NEED Sum #-}
newtype {-#  #-} Sum a;

{-# NEED Product #-}
newtype {-#  #-} Product a;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface Control.Applicative
{-# NEED Const #-}
newtype {-#  #-} Const a b;

{-# NEED WrappedMonad #-}
newtype {-#  #-} WrappedMonad a b;

{-# NEED WrappedArrow #-}
newtype {-#  #-} WrappedArrow a b c;

{-# NEED ZipList #-}
newtype {-#  #-} ZipList a;
interface Data.Traversable
{-# NEED Id #-}
newtype {-#  #-} Id a;
interface Data.Sequence
{-# NEED Digit #-}
data Digit a;

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

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

{-# NEED ViewR #-}
data ViewR a;
interface Control.Arrow
{-# NEED ArrowMonad #-}
newtype {-#  #-} (Control.Arrow.ArrowApply a) => ArrowMonad a b;

{-# NEED ArrowApply #-}
class (Control.Arrow.Arrow a) => ArrowApply a;

{-# NEED Arrow #-}
class Arrow a;
interface Data.Sequence
{-# NEED Seq #-}
newtype {-#  #-} Seq a;

{-# NEED Elem #-}
newtype {-#  #-} Elem a;

{-# NEED FingerTree #-}
data FingerTree a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface ! Data.Tree
{-# NEED unfoldForestM_BF #-}
unfoldForestM_BF{-# 1 #-}::(Prelude.Monad b) => ((a -> (b (c,[a]))) -> ([a] -> (b (Forest c))));

{-# NEED unfoldTreeM_BF #-}
unfoldTreeM_BF{-# 2 #-}::(Prelude.Monad b) => ((a -> (b (c,[a]))) -> (a -> (b (Tree c))));

{-# NEED unfoldForestM #-}
unfoldForestM{-# 1 #-}::(Prelude.Monad b) => ((a -> (b (c,[a]))) -> ([a] -> (b (Forest c))));

{-# NEED unfoldTreeM #-}
unfoldTreeM{-# 2 #-}::(Prelude.Monad b) => ((a -> (b (c,[a]))) -> (a -> (b (Tree c))));

{-# NEED unfoldForest #-}
unfoldForest{-# 1 #-}::((a -> (b,[a])) -> ([a] -> (Forest b)));

{-# NEED unfoldTree #-}
unfoldTree{-# 2 #-}::((a -> (b,[a])) -> (a -> (Tree b)));

{-# NEED levels #-}
levels{-# 1 #-}::((Tree a) -> [[a]]);

{-# NEED flatten #-}
flatten{-# 1 #-}::((Tree a) -> [a]);

{-# NEED drawForest #-}
drawForest{-# 0 #-}::((Forest Prelude.String) -> Prelude.String);

{-# NEED drawTree #-}
drawTree{-# 0 #-}::((Tree Prelude.String) -> Prelude.String);

{-# NEED {Tree Node rootLabel subForest} Forest #-}
data Tree a
  = Node {rootLabel :: a} {subForest :: (Forest a)};
type {-# 1 #-} Forest a = [(Tree a)];
}