interface Distribution.Compat.Map where {

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

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

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

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

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

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

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

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

{-# 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 (Data.Typeable.Typeable a,Data.Typeable.Typeable b) => Data.Typeable.Typeable (Data.Map.Map a b);

{-# NEED #-}
instance (Prelude.Ord a) => Data.Monoid.Monoid (Data.Map.Map 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.Functor NHC.Internal.IO;

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

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

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

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

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

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

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

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

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

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

{-# NEED #-}
instance (Prelude.Ord a,Prelude.Ord b) => Prelude.Ord (Data.Map.Map a b);
interface Data.Typeable
{-# NEED #-}
class Typeable a;
interface NHC.Internal
{-# NEED IO #-}
newtype {-#  #-} IO a;

{-# NEED World #-}
data World;
interface Ratio
{-# NEED Ratio #-}
data Ratio a;
interface ! Data.Map
{-# NEED lookup #-}
lookup{-# 2 #-}::(Prelude.Monad c,Prelude.Ord a) => (a -> ((Data.Map.Map a b) -> (c b)));

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

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

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

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

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

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

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

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

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

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

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

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

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

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