interface BinArray where {

{-# NEED #-}
instance Binary.Binary (BinArrayFileHeader a);

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

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

{-# NEED #-}
instance Binary.Binary ();

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

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

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

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

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

{-# NEED #-}
instance Binary.Binary Binary.BinPtr;

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

{-# NEED #-}
instance Binary.Binary UnboxedArray;

{-# NEED #-}
instance Prelude.Eq Binary.BinIOMode;

{-# NEED #-}
instance Prelude.Eq Binary.BinPtr;

{-# NEED #-}
instance Prelude.Num Binary.BinPtr;

{-# NEED #-}
instance Prelude.Ord Binary.BinIOMode;

{-# NEED #-}
instance Prelude.Ord Binary.BinPtr;

{-# NEED #-}
instance Prelude.Enum Binary.BinIOMode;

{-# NEED #-}
instance Prelude.Enum Binary.BinPtr;

{-# NEED #-}
instance Prelude.Show Binary.BinPtr;
interface BinArray
{-# NEED BinArrayFileHeader #-}
data BinArrayFileHeader a;
interface Binary
{-# NEED BinIOMode #-}
data BinIOMode;
interface ! BinArray
{-# NEED getBinArray #-}
getBinArray{-# 1 #-}::(Binary.Binary a) => (Prelude.FilePath -> (Prelude.IO (BinArray a)));

{-# NEED putBinArray #-}
putBinArray{-# 2 #-}::(Binary.Binary a) => (Prelude.FilePath -> ((BinArray a) -> (Prelude.IO ())));

{-# NEED fromBinArray #-}
fromBinArray{-# 2 #-}::(Binary.Binary a) => ((BinArray a) -> (Prelude.Int -> (Prelude.IO a)));

{-# NEED intoBinArray #-}
intoBinArray{-# 2 #-}::(Binary.Binary a) => ((BinArray a) -> (a -> (Prelude.IO Prelude.Int)));

{-# NEED newBinArray #-}
newBinArray{-# 2 #-}::(Binary.Binary a) => (Prelude.Int -> (a -> (Prelude.IO (BinArray a))));
interface Binary
{-# NEED Binary #-}
class Binary a;
interface ! BinArray
{-# NEED {BinArray BA baSize baHandle baDefault baArray} #-}
data BinArray a
  = BA {baSize :: Prelude.Int} {baHandle :: Binary.BinHandle} {baDefault :: (Binary.Bin a)} {baArray :: UnboxedArray};
interface BinArray
{-# NEED UnboxedArray #-}
newtype {-#  #-} UnboxedArray;
interface Binary
{-# NEED Bin #-}
type {-# 1 #-} Bin a = Binary.BinPtr;

{-# NEED BinPtr #-}
newtype {-#  #-} BinPtr;

{-# NEED BinHandle #-}
newtype {-#  #-} BinHandle;
}
