interface Data.Map where {
infixl  9 \\;
infixl  9 !;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Traversable.Traversable (Map a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Control.Applicative.Applicative (Data.Traversable.StateL a);

{-# NEED #-}
instance Control.Applicative.Applicative (Data.Traversable.StateR a);

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

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

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

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

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

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

{-# NEED #-}
instance Prelude.Functor (Map a);

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

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

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

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

{-# NEED #-}
instance Prelude.Functor (Data.Traversable.StateL a);

{-# NEED #-}
instance Prelude.Functor (Data.Traversable.StateR a);

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

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

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

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

{-# NEED #-}
instance Data.Typeable.Typeable2 NHC.IOExtras.IOArray;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance Data.Foldable.Foldable (Map a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Read a,Prelude.Ord a) => Prelude.Read (Data.Set.Set a);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Data.Typeable.Typeable a) => Data.Typeable.Typeable (NHC.FFI.FunPtr 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.Ptr 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 (NHC.IOExtras.IOArray a b);

{-# 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 (Array.Array a b);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Data.Monoid.Monoid b) => Data.Monoid.Monoid (a -> b);
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 ArrowMonad #-}
newtype {-#  #-} (Control.Arrow.ArrowApply a) => ArrowMonad a b;

{-# NEED ArrowApply #-}
class (Control.Arrow.Arrow a) => ArrowApply a;
interface Control.Applicative
{-# NEED ZipList #-}
newtype {-#  #-} ZipList a;
interface Control.Arrow
{-# NEED Arrow #-}
class (Control.Category.Category a) => Arrow a;
interface Control.Category
{-# NEED Category #-}
class Category a;
interface Control.Applicative
{-# NEED WrappedArrow #-}
newtype {-#  #-} WrappedArrow a b c;

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

{-# NEED Const #-}
newtype {-#  #-} Const a b;
interface Data.Traversable
{-# NEED StateL #-}
newtype {-#  #-} StateL a b;

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

{-# NEED Id #-}
newtype {-#  #-} Id a;
interface Data.HashTable
{-# NEED Inserts #-}
data Inserts;
interface Data.Typeable
{-# NEED Key #-}
newtype {-#  #-} Key;

{-# NEED KeyPr #-}
data KeyPr;
interface IO
{-# NEED HandlePosn #-}
data HandlePosn;
interface Data.HashTable
{-# NEED HashData #-}
data HashData;
interface DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED BufferMode #-}
data BufferMode;

{-# NEED SeekMode #-}
data SeekMode;

{-# NEED IOMode #-}
data IOMode;
interface Data.Char
{-# NEED GeneralCategory #-}
data GeneralCategory;
interface Data.Typeable
{-# NEED TypeRep #-}
data TypeRep;

{-# NEED TyCon #-}
data TyCon;
interface NHC.FFI
{-# NEED StablePtr #-}
data StablePtr a;

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

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

{-# NEED Ptr #-}
data Ptr a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;
interface NHC.DErrNo
{-# NEED ErrNo #-}
data ErrNo;
interface IO
{-# NEED Handle #-}
newtype {-#  #-} Handle;
interface NHC.Internal
{-# NEED World #-}
data World;
interface NHC.IOExtras
{-# NEED IOArray #-}
data (Ix.Ix a) => IOArray a b;

{-# NEED IORef #-}
newtype {-#  #-} IORef a;
interface Array
{-# NEED Array #-}
data (Ix.Ix a) => Array a b;
interface Ix
{-# NEED Ix #-}
class (Prelude.Ord a) => Ix a;
interface Data.Typeable
{-# NEED Typeable #-}
class Typeable a;
interface NHC.FFI
{-# NEED CInt #-}
newtype {-#  #-} CInt;

{-# NEED Int64 #-}
data Int64;

{-# NEED Int32 #-}
data Int32;

{-# NEED Int16 #-}
data Int16;

{-# NEED Int8 #-}
data Int8;

{-# NEED Word8 #-}
data Word8;

{-# NEED Word16 #-}
data Word16;

{-# NEED Word32 #-}
data Word32;

{-# NEED Word64 #-}
data Word64;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface Data.Monoid
{-# NEED Product #-}
newtype {-#  #-} Product a;

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

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

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

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

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

{-# NEED Monoid #-}
class Monoid a;
interface ! Data.Map
{-# NEED valid #-}
valid{-# 1 #-}::(Prelude.Ord a) => ((Map a b) -> Prelude.Bool);

{-# NEED showTreeWith #-}
showTreeWith{-# 4 #-}::((a -> (b -> Prelude.String)) -> (Prelude.Bool -> (Prelude.Bool -> ((Map a b) -> Prelude.String))));

{-# NEED showTree #-}
showTree{-# 1 #-}::(Prelude.Show a,Prelude.Show b) => ((Map a b) -> Prelude.String);

{-# NEED deleteFindMax #-}
deleteFindMax{-# 1 #-}::((Map a b) -> ((a,b),(Map a b)));

{-# NEED deleteFindMin #-}
deleteFindMin{-# 1 #-}::((Map a b) -> ((a,b),(Map a b)));

{-# NEED splitLookup #-}
splitLookup{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> ((Map a b),(Prelude.Maybe b),(Map a b))));

{-# NEED split #-}
split{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> ((Map a b),(Map a b))));

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

{-# NEED fromAscListWithKey #-}
fromAscListWithKey{-# 2 #-}::(Prelude.Eq a) => ((a -> (b -> (b -> b))) -> ([(a,b)] -> (Map a b)));

{-# NEED fromAscListWith #-}
fromAscListWith{-# 2 #-}::(Prelude.Eq b) => ((a -> (a -> a)) -> ([(b,a)] -> (Map b a)));

{-# NEED fromAscList #-}
fromAscList{-# 1 #-}::(Prelude.Eq a) => ([(a,b)] -> (Map a b));

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

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

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

{-# NEED fromListWithKey #-}
fromListWithKey{-# 2 #-}::(Prelude.Ord a) => ((a -> (b -> (b -> b))) -> ([(a,b)] -> (Map a b)));

{-# NEED fromListWith #-}
fromListWith{-# 2 #-}::(Prelude.Ord b) => ((a -> (a -> a)) -> ([(b,a)] -> (Map b a)));

{-# NEED fromList #-}
fromList{-# 1 #-}::(Prelude.Ord a) => ([(a,b)] -> (Map a b));

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

{-# NEED keysSet #-}
keysSet{-# 1 #-}::((Map a b) -> (Data.Set.Set a));
interface Data.Set
{-# NEED Set #-}
data Set a;
interface ! Data.Map
{-# NEED keys #-}
keys{-# 1 #-}::((Map a b) -> [a]);

{-# NEED elems #-}
elems{-# 1 #-}::((Map a b) -> [b]);

{-# NEED foldlWithKey #-}
foldlWithKey{-# 3 #-}::((a -> (b -> (c -> a))) -> (a -> ((Map b c) -> a)));

{-# NEED foldrWithKey #-}
foldrWithKey{-# 3 #-}::((a -> (b -> (c -> c))) -> (c -> ((Map a b) -> c)));

{-# NEED foldWithKey #-}
foldWithKey{-# 3 #-}::((a -> (b -> (c -> c))) -> (c -> ((Map a b) -> c)));

{-# NEED fold #-}
fold{-# 3 #-}::((a -> (b -> b)) -> (b -> ((Map c a) -> b)));

{-# NEED mapKeysMonotonic #-}
mapKeysMonotonic{-# 2 #-}::((a -> b) -> ((Map a c) -> (Map b c)));

{-# NEED mapKeysWith #-}
mapKeysWith{-# 2 #-}::(Prelude.Ord c) => ((a -> (a -> a)) -> ((b -> c) -> ((Map b a) -> (Map c a))));

{-# NEED mapKeys #-}
mapKeys{-# 0 #-}::(Prelude.Ord b) => ((a -> b) -> ((Map a c) -> (Map b c)));

{-# NEED mapAccumRWithKey #-}
mapAccumRWithKey{-# 3 #-}::((a -> (b -> (c -> (a,d)))) -> (a -> ((Map b c) -> (a,(Map b d)))));

{-# NEED mapAccumWithKey #-}
mapAccumWithKey{-# 3 #-}::((a -> (b -> (c -> (a,d)))) -> (a -> ((Map b c) -> (a,(Map b d)))));

{-# NEED mapAccum #-}
mapAccum{-# 3 #-}::((a -> (b -> (a,c))) -> (a -> ((Map d b) -> (a,(Map d c)))));

{-# NEED mapWithKey #-}
mapWithKey{-# 2 #-}::((a -> (b -> c)) -> ((Map a b) -> (Map a c)));

{-# NEED map #-}
map{-# 2 #-}::((a -> b) -> ((Map c a) -> (Map c b)));

{-# NEED mapEitherWithKey #-}
mapEitherWithKey{-# 2 #-}::(Prelude.Ord a) => ((a -> (b -> (Prelude.Either c d))) -> ((Map a b) -> ((Map a c),(Map a d))));

{-# NEED mapEither #-}
mapEither{-# 2 #-}::(Prelude.Ord d) => ((a -> (Prelude.Either b c)) -> ((Map d a) -> ((Map d b),(Map d c))));

{-# NEED mapMaybeWithKey #-}
mapMaybeWithKey{-# 2 #-}::(Prelude.Ord a) => ((a -> (b -> (Prelude.Maybe c))) -> ((Map a b) -> (Map a c)));

{-# NEED mapMaybe #-}
mapMaybe{-# 2 #-}::(Prelude.Ord c) => ((a -> (Prelude.Maybe b)) -> ((Map c a) -> (Map c b)));

{-# NEED partitionWithKey #-}
partitionWithKey{-# 2 #-}::(Prelude.Ord a) => ((a -> (b -> Prelude.Bool)) -> ((Map a b) -> ((Map a b),(Map a b))));

{-# NEED partition #-}
partition{-# 2 #-}::(Prelude.Ord b) => ((a -> Prelude.Bool) -> ((Map b a) -> ((Map b a),(Map b a))));

{-# NEED filterWithKey #-}
filterWithKey{-# 2 #-}::(Prelude.Ord a) => ((a -> (b -> Prelude.Bool)) -> ((Map a b) -> (Map a b)));

{-# NEED filter #-}
filter{-# 2 #-}::(Prelude.Ord b) => ((a -> Prelude.Bool) -> ((Map b a) -> (Map b a)));

{-# NEED isProperSubmapOfBy #-}
isProperSubmapOfBy{-# 3 #-}::(Prelude.Ord c) => ((a -> (b -> Prelude.Bool)) -> ((Map c a) -> ((Map c b) -> Prelude.Bool)));

{-# NEED isProperSubmapOf #-}
isProperSubmapOf{-# 2 #-}::(Prelude.Ord a,Prelude.Eq b) => ((Map a b) -> ((Map a b) -> Prelude.Bool));

{-# NEED isSubmapOfBy #-}
isSubmapOfBy{-# 3 #-}::(Prelude.Ord c) => ((a -> (b -> Prelude.Bool)) -> ((Map c a) -> ((Map c b) -> Prelude.Bool)));

{-# NEED isSubmapOf #-}
isSubmapOf{-# 2 #-}::(Prelude.Ord a,Prelude.Eq b) => ((Map a b) -> ((Map a b) -> Prelude.Bool));

{-# NEED intersectionWithKey #-}
intersectionWithKey{-# 3 #-}::(Prelude.Ord a) => ((a -> (b -> (c -> d))) -> ((Map a b) -> ((Map a c) -> (Map a d))));

{-# NEED intersectionWith #-}
intersectionWith{-# 3 #-}::(Prelude.Ord d) => ((a -> (b -> c)) -> ((Map d a) -> ((Map d b) -> (Map d c))));

{-# NEED intersection #-}
intersection{-# 2 #-}::(Prelude.Ord a) => ((Map a b) -> ((Map a c) -> (Map a b)));

{-# NEED differenceWithKey #-}
differenceWithKey{-# 3 #-}::(Prelude.Ord a) => ((a -> (b -> (c -> (Prelude.Maybe b)))) -> ((Map a b) -> ((Map a c) -> (Map a b))));

{-# NEED differenceWith #-}
differenceWith{-# 3 #-}::(Prelude.Ord c) => ((a -> (b -> (Prelude.Maybe a))) -> ((Map c a) -> ((Map c b) -> (Map c a))));

{-# NEED difference #-}
difference{-# 2 #-}::(Prelude.Ord a) => ((Map a b) -> ((Map a c) -> (Map a b)));

{-# NEED unionWithKey #-}
unionWithKey{-# 3 #-}::(Prelude.Ord a) => ((a -> (b -> (b -> b))) -> ((Map a b) -> ((Map a b) -> (Map a b))));

{-# NEED unionWith #-}
unionWith{-# 3 #-}::(Prelude.Ord b) => ((a -> (a -> a)) -> ((Map b a) -> ((Map b a) -> (Map b a))));

{-# NEED union #-}
union{-# 2 #-}::(Prelude.Ord a) => ((Map a b) -> ((Map a b) -> (Map a b)));

{-# NEED unionsWith #-}
unionsWith{-# 2 #-}::(Prelude.Ord b) => ((a -> (a -> a)) -> ([(Map b a)] -> (Map b a)));

{-# NEED unions #-}
unions{-# 1 #-}::(Prelude.Ord a) => ([(Map a b)] -> (Map a b));

{-# NEED maxView #-}
maxView{-# 1 #-}::((Map a b) -> (Prelude.Maybe (b,(Map a b))));

{-# NEED minView #-}
minView{-# 1 #-}::((Map a b) -> (Prelude.Maybe (b,(Map a b))));

{-# NEED maxViewWithKey #-}
maxViewWithKey{-# 1 #-}::((Map a b) -> (Prelude.Maybe ((a,b),(Map a b))));

{-# NEED minViewWithKey #-}
minViewWithKey{-# 1 #-}::((Map a b) -> (Prelude.Maybe ((a,b),(Map a b))));

{-# NEED updateMaxWithKey #-}
updateMaxWithKey{-# 2 #-}::((a -> (b -> (Prelude.Maybe b))) -> ((Map a b) -> (Map a b)));

{-# NEED updateMinWithKey #-}
updateMinWithKey{-# 2 #-}::((a -> (b -> (Prelude.Maybe b))) -> ((Map a b) -> (Map a b)));

{-# NEED updateMax #-}
updateMax{-# 2 #-}::((a -> (Prelude.Maybe a)) -> ((Map b a) -> (Map b a)));

{-# NEED updateMin #-}
updateMin{-# 2 #-}::((a -> (Prelude.Maybe a)) -> ((Map b a) -> (Map b a)));

{-# NEED deleteMax #-}
deleteMax{-# 1 #-}::((Map a b) -> (Map a b));

{-# NEED deleteMin #-}
deleteMin{-# 1 #-}::((Map a b) -> (Map a b));

{-# NEED findMax #-}
findMax{-# 1 #-}::((Map a b) -> (a,b));

{-# NEED findMin #-}
findMin{-# 1 #-}::((Map a b) -> (a,b));

{-# NEED deleteAt #-}
deleteAt{-# 2 #-}::(Prelude.Int -> ((Map a b) -> (Map a b)));

{-# NEED updateAt #-}
updateAt{-# 3 #-}::((a -> (b -> (Prelude.Maybe b))) -> (Prelude.Int -> ((Map a b) -> (Map a b))));

{-# NEED elemAt #-}
elemAt{-# 2 #-}::(Prelude.Int -> ((Map a b) -> (a,b)));

{-# NEED lookupIndex #-}
lookupIndex{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> (Prelude.Maybe Prelude.Int)));

{-# NEED findIndex #-}
findIndex{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> Prelude.Int));

{-# NEED alter #-}
alter{-# 3 #-}::(Prelude.Ord b) => (((Prelude.Maybe a) -> (Prelude.Maybe a)) -> (b -> ((Map b a) -> (Map b a))));

{-# NEED updateLookupWithKey #-}
updateLookupWithKey{-# 3 #-}::(Prelude.Ord a) => ((a -> (b -> (Prelude.Maybe b))) -> (a -> ((Map a b) -> ((Prelude.Maybe b),(Map a b)))));

{-# NEED updateWithKey #-}
updateWithKey{-# 3 #-}::(Prelude.Ord a) => ((a -> (b -> (Prelude.Maybe b))) -> (a -> ((Map a b) -> (Map a b))));

{-# NEED update #-}
update{-# 3 #-}::(Prelude.Ord b) => ((a -> (Prelude.Maybe a)) -> (b -> ((Map b a) -> (Map b a))));

{-# NEED adjustWithKey #-}
adjustWithKey{-# 3 #-}::(Prelude.Ord a) => ((a -> (b -> b)) -> (a -> ((Map a b) -> (Map a b))));

{-# NEED adjust #-}
adjust{-# 3 #-}::(Prelude.Ord b) => ((a -> a) -> (b -> ((Map b a) -> (Map b a))));

{-# NEED delete #-}
delete{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> (Map a b)));

{-# NEED insertLookupWithKey #-}
insertLookupWithKey{-# 4 #-}::(Prelude.Ord a) => ((a -> (b -> (b -> b))) -> (a -> (b -> ((Map a b) -> ((Prelude.Maybe b),(Map a b))))));

{-# NEED insertWithKey' #-}
insertWithKey'{-# 4 #-}::(Prelude.Ord a) => ((a -> (b -> (b -> b))) -> (a -> (b -> ((Map a b) -> (Map a b)))));

{-# NEED insertWithKey #-}
insertWithKey{-# 4 #-}::(Prelude.Ord a) => ((a -> (b -> (b -> b))) -> (a -> (b -> ((Map a b) -> (Map a b)))));

{-# NEED insertWith' #-}
insertWith'{-# 4 #-}::(Prelude.Ord b) => ((a -> (a -> a)) -> (b -> (a -> ((Map b a) -> (Map b a)))));

{-# NEED insertWith #-}
insertWith{-# 4 #-}::(Prelude.Ord b) => ((a -> (a -> a)) -> (b -> (a -> ((Map b a) -> (Map b a)))));

{-# NEED insert #-}
insert{-# 3 #-}::(Prelude.Ord a) => (a -> (b -> ((Map a b) -> (Map a b))));

{-# NEED singleton #-}
singleton{-# 2 #-}::(a -> (b -> (Map a b)));

{-# NEED empty #-}
empty{-# 0 #-}::(Map a b);

{-# NEED findWithDefault #-}
findWithDefault{-# 3 #-}::(Prelude.Ord b) => (a -> (b -> ((Map b a) -> a)));

{-# NEED notMember #-}
notMember{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> Prelude.Bool));

{-# NEED member #-}
member{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> Prelude.Bool));

{-# NEED lookup #-}
lookup{-# 2 #-}::(Prelude.Ord a) => (a -> ((Map a b) -> (Prelude.Maybe b)));

{-# NEED size #-}
size{-# 1 #-}::((Map a b) -> Prelude.Int);

{-# NEED null #-}
null{-# 1 #-}::((Map a b) -> Prelude.Bool);

{-# NEED (\\) #-}
(\\){-# 2 #-}::(Prelude.Ord a) => ((Map a b) -> ((Map a c) -> (Map a b)));

{-# NEED (!) #-}
(!){-# 2 #-}::(Prelude.Ord a) => ((Map a b) -> (a -> b));

{-# NEED Map #-}
data Map a b;
}
