text:
{-# LANGUAGE CPP #-}
module Control.Instances.Package.Base () where
#ifdef MIN_VERSION_base
#if MIN_VERSION_base(4,10,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fail ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.IO.Class ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bifoldable ()
import Data.Bifunctor ()
import Data.Bitraversable ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.Functor.Classes ()
import Data.Functor.Compose ()
import Data.Functor.Const ()
import Data.Functor.Identity ()
import Data.Functor.Product ()
import Data.Functor.Sum ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.Kind ()
import Data.List ()
import Data.List.NonEmpty ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.Semigroup ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Void ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.ExecutionStack ()
import GHC.ExecutionStack.Internal ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Lock ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IO.Unsafe ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Natural ()
import GHC.Num ()
import GHC.OldList ()
import GHC.OverloadedLabels ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.Records ()
import GHC.RTS.Flags ()
import GHC.ST ()
import GHC.StaticPtr ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stack.CCS ()
import GHC.Stack.Types ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.TypeNats ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Numeric.Natural ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Type.Reflection ()
import Type.Reflection.Unsafe ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,9,1)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fail ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.IO.Class ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bifunctor ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.Functor.Classes ()
import Data.Functor.Compose ()
import Data.Functor.Const ()
import Data.Functor.Identity ()
import Data.Functor.Product ()
import Data.Functor.Sum ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.Kind ()
import Data.List ()
import Data.List.NonEmpty ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.Semigroup ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Void ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.ExecutionStack ()
import GHC.ExecutionStack.Internal ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IO.Unsafe ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Natural ()
import GHC.Num ()
import GHC.OldList ()
import GHC.OverloadedLabels ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.RTS.Flags ()
import GHC.ST ()
import GHC.StaticPtr ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stack.CCS ()
import GHC.Stack.Types ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Numeric.Natural ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,9,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fail ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.IO.Class ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bifunctor ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.Functor.Classes ()
import Data.Functor.Compose ()
import Data.Functor.Const ()
import Data.Functor.Identity ()
import Data.Functor.Product ()
import Data.Functor.Sum ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.Kind ()
import Data.List ()
import Data.List.NonEmpty ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.Semigroup ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Void ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.ExecutionStack ()
import GHC.ExecutionStack.Internal ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IO.Unsafe ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Natural ()
import GHC.Num ()
import GHC.OldList ()
import GHC.OverloadedLabels ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.RTS.Flags ()
import GHC.ST ()
import GHC.StaticPtr ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stack.CCS ()
import GHC.Stack.Types ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Numeric.Natural ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,8,2)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bifunctor ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.Functor.Identity ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Void ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.IP ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Natural ()
import GHC.Num ()
import GHC.OldList ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.RTS.Flags ()
import GHC.ST ()
import GHC.StaticPtr ()
import GHC.STRef ()
import GHC.Show ()
import GHC.SrcLoc ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Numeric.Natural ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,8,1)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bifunctor ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.Functor.Identity ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Void ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.IP ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Natural ()
import GHC.Num ()
import GHC.OldList ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.RTS.Flags ()
import GHC.ST ()
import GHC.StaticPtr ()
import GHC.STRef ()
import GHC.Show ()
import GHC.SrcLoc ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Numeric.Natural ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,8,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bifunctor ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.Functor.Identity ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Void ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.IP ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Natural ()
import GHC.Num ()
import GHC.OldList ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.RTS.Flags ()
import GHC.ST ()
import GHC.StaticPtr ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Numeric.Natural ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,7,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.OldTypeable ()
import Data.OldTypeable.Internal ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.IP ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Num ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.ST ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,7,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.OldTypeable ()
import Data.OldTypeable.Internal ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.IP ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Num ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.ST ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,7,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Strict ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Coerce ()
import Data.Complex ()
import Data.Data ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.OldTypeable ()
import Data.OldTypeable.Internal ()
import Data.Ord ()
import Data.Proxy ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Type.Bool ()
import Data.Type.Coercion ()
import Data.Type.Equality ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.Concurrent ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Unsafe ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import GHC.Arr ()
import GHC.Base ()
import GHC.Char ()
import GHC.Conc ()
import GHC.Conc.IO ()
import GHC.Conc.Signal ()
import GHC.Conc.Sync ()
import GHC.ConsoleHandler ()
import GHC.Constants ()
import GHC.Desugar ()
import GHC.Enum ()
import GHC.Environment ()
import GHC.Err ()
import GHC.Exception ()
import GHC.Exts ()
import GHC.Fingerprint ()
import GHC.Fingerprint.Type ()
import GHC.Float ()
import GHC.Float.ConversionUtils ()
import GHC.Float.RealFracMethods ()
import GHC.Foreign ()
import GHC.ForeignPtr ()
import GHC.GHCi ()
import GHC.Generics ()
import GHC.IO ()
import GHC.IO.Buffer ()
import GHC.IO.BufferedIO ()
import GHC.IO.Device ()
import GHC.IO.Encoding ()
import GHC.IO.Encoding.CodePage ()
import GHC.IO.Encoding.Failure ()
import GHC.IO.Encoding.Iconv ()
import GHC.IO.Encoding.Latin1 ()
import GHC.IO.Encoding.Types ()
import GHC.IO.Encoding.UTF16 ()
import GHC.IO.Encoding.UTF32 ()
import GHC.IO.Encoding.UTF8 ()
import GHC.IO.Exception ()
import GHC.IO.FD ()
import GHC.IO.Handle ()
import GHC.IO.Handle.FD ()
import GHC.IO.Handle.Internals ()
import GHC.IO.Handle.Text ()
import GHC.IO.Handle.Types ()
import GHC.IO.IOMode ()
import GHC.IOArray ()
import GHC.IORef ()
import GHC.IP ()
import GHC.Int ()
import GHC.List ()
import GHC.MVar ()
import GHC.Num ()
import GHC.PArr ()
import GHC.Pack ()
import GHC.Profiling ()
import GHC.Ptr ()
import GHC.Read ()
import GHC.Real ()
import GHC.ST ()
import GHC.STRef ()
import GHC.Show ()
import GHC.Stable ()
import GHC.Stack ()
import GHC.Stats ()
import GHC.Storable ()
import GHC.TopHandler ()
import GHC.TypeLits ()
import GHC.Unicode ()
import GHC.Weak ()
import GHC.Word ()
import Numeric ()
import Prelude ()
import System.CPUTime ()
import System.Console.GetOpt ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import System.Timeout ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,6,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Strict ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Utils ()
import Foreign.Marshal.Unsafe ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,6,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Strict ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Utils ()
import Foreign.Marshal.Unsafe ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,5,1)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Strict ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Utils ()
import Foreign.Marshal.Unsafe ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,5,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Strict ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Utils ()
import Foreign.Marshal.Unsafe ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,4,1)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Strict ()
import Control.Monad.Group ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Utils ()
import Foreign.Marshal.Unsafe ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,4,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Safe ()
import Control.Monad.ST.Unsafe ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Lazy.Safe ()
import Control.Monad.ST.Lazy.Unsafe ()
import Control.Monad.ST.Strict ()
import Control.Monad.Group ()
import Control.Monad.Zip ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Typeable.Internal ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.ForeignPtr.Safe ()
import Foreign.ForeignPtr.Unsafe ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Safe ()
import Foreign.Marshal.Utils ()
import Foreign.Marshal.Unsafe ()
import Foreign.Ptr ()
import Foreign.Safe ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,3,1)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,3,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,2,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,2,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,2,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.Functor ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,1,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(4,0,0)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Exception.Base ()
import Control.OldException ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Data ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(3,0,3)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#elif MIN_VERSION_base(3,0,3)
import Control.Applicative ()
import Control.Arrow ()
import Control.Category ()
import Control.Concurrent ()
import Control.Concurrent.Chan ()
import Control.Concurrent.MVar ()
import Control.Concurrent.QSem ()
import Control.Concurrent.QSemN ()
import Control.Concurrent.SampleVar ()
import Control.Exception ()
import Control.Monad ()
import Control.Monad.Fix ()
import Control.Monad.Instances ()
import Control.Monad.ST ()
import Control.Monad.ST.Lazy ()
import Control.Monad.ST.Strict ()
import Data.Bits ()
import Data.Bool ()
import Data.Char ()
import Data.Complex ()
import Data.Dynamic ()
import Data.Either ()
import Data.Eq ()
import Data.Fixed ()
import Data.Foldable ()
import Data.Function ()
import Data.HashTable ()
import Data.IORef ()
import Data.Int ()
import Data.Ix ()
import Data.List ()
import Data.Maybe ()
import Data.Monoid ()
import Data.Ord ()
import Data.Ratio ()
import Data.STRef ()
import Data.STRef.Lazy ()
import Data.STRef.Strict ()
import Data.String ()
import Data.Traversable ()
import Data.Tuple ()
import Data.Typeable ()
import Data.Unique ()
import Data.Version ()
import Data.Word ()
import Debug.Trace ()
import Foreign ()
import Foreign.C ()
import Foreign.C.Error ()
import Foreign.C.String ()
import Foreign.C.Types ()
import Foreign.ForeignPtr ()
import Foreign.Marshal ()
import Foreign.Marshal.Alloc ()
import Foreign.Marshal.Array ()
import Foreign.Marshal.Error ()
import Foreign.Marshal.Pool ()
import Foreign.Marshal.Utils ()
import Foreign.Ptr ()
import Foreign.StablePtr ()
import Foreign.Storable ()
import Numeric ()
import Prelude ()
import System.Console.GetOpt ()
import System.CPUTime ()
import System.Environment ()
import System.Exit ()
import System.IO ()
import System.IO.Error ()
import System.IO.Unsafe ()
import System.Info ()
import System.Mem ()
import System.Mem.StableName ()
import System.Mem.Weak ()
import System.Posix.Internals ()
import System.Posix.Types ()
import Text.ParserCombinators.ReadP ()
import Text.ParserCombinators.ReadPrec ()
import Text.Printf ()
import Text.Read ()
import Text.Read.Lex ()
import Text.Show ()
import Text.Show.Functions ()
import Unsafe.Coerce ()
#endif
#endif

max_stars_repo_name: clintonmead/ghc-instances

max_issues_repo_name: clintonmead/ghc-instances

max_forks_repo_name: clintonmead/ghc-instances


text:
{-# LANGUAGE ScopedTypeVariables                      #-}
{-# LANGUAGE TypeApplications                         #-}
{-# LANGUAGE TypeInType                               #-}
{-# LANGUAGE TypeOperators                            #-}
{-# OPTIONS_GHC -fplugin GHC.TypeLits.KnownNat.Solver #-}

import           Control.DeepSeq
import           Control.Exception
import           Criterion.Main
import           Data.Char
import           Data.Complex
import           GHC.TypeNats
import           Numeric.EMD
import           Numeric.HHT
import           Statistics.Transform
import           Text.Printf
import qualified Data.Vector          as UV
import qualified Data.Vector.Sized    as V
import qualified System.Random.MWC    as MWC

main :: IO ()
main = do
    g     <- MWC.initialize
           . UV.fromList
           . map (fromIntegral . ord)
           $ "hello world"

    test256    <- evaluate . force =<< generateData @8  g
    test1024   <- evaluate . force =<< generateData @10 g
    test4096   <- evaluate . force =<< generateData @12 g

    itest256   <- evaluate . force $ emd defaultEO test256
    itest1024  <- evaluate . force $ emd defaultEO test1024
    itest4096  <- evaluate . force $ emd defaultEO test4096

    htest256   <- evaluate . force $ hhtEmd itest256
    htest1024  <- evaluate . force $ hhtEmd itest1024
    htest4096  <- evaluate . force $ hhtEmd itest4096

    let imfs256   = length . emdIMFs $ itest256
        imfs1024  = length . emdIMFs $ itest1024
        imfs4096  = length . emdIMFs $ itest4096

    defaultMainWith defaultConfig [
        bgroup "emd"
          [ bench (printf "256 (%d imfs)"   imfs256  ) $ nf (emd defaultEO) test256
          , bench (printf "1024 (%d imfs)"  imfs1024 ) $ nf (emd defaultEO) test1024
          , bench (printf "4096 (%d imfs)"  imfs4096 ) $ nf (emd defaultEO) test4096
          ]
      , bgroup "hhtEmd"
          [ bench "256"   $ nf hhtEmd itest256
          , bench "1024"  $ nf hhtEmd itest1024
          , bench "4096"  $ nf hhtEmd itest4096
          ]
      , bgroup "iemd"
          [ bench "256"   $ nf iemd itest256
          , bench "1024"  $ nf iemd itest1024
          , bench "4096"  $ nf iemd itest4096
          ]
      , bgroup "ihhtEmd"
          [ bench "256"   $ nf ihhtEmd htest256
          , bench "1024"  $ nf ihhtEmd htest1024
          , bench "4096"  $ nf ihhtEmd htest4096
          ]
      ]

generateData
    :: KnownNat n
    => MWC.GenIO
    -> IO (V.Vector (2^n) Double)
generateData g = fmap (fmap realPart . ifftSized) . V.generateM $ \i ->
    let i' = recip . (+ 1) . fromIntegral $ i
    in  (:+) <$> MWC.uniformR (-i', i') g
             <*> MWC.uniformR (-i', i') g

ifftSized
    :: V.Vector (2^n) (Complex Double)
    -> V.Vector (2^n) (Complex Double)
ifftSized = V.withVectorUnsafe ifft

ext: hs

max_stars_repo_name: mstksg/emd

max_issues_repo_name: mstksg/emd

max_forks_repo_name: mstksg/emd


text:
module Main where

import Functions

import Math.FFT
import Control.Arrow
import Data.Array.CArray
import Data.Complex
import Foreign.Storable.Complex()

import Control.Lens
import Data.Colour
import Data.Colour.Names
import Data.Default.Class
import Graphics.Rendering.Chart
import Graphics.Rendering.Chart.Backend.Cairo

import Codec.Picture

import System.Random

import Control.Exception

----------

numOfData :: Int -- Frequency
numOfData = 256

rawData :: [Double]
rawData = take numOfData $ randomRs (-1, 1) $ mkStdGen 7

inputData :: [(Int, Double)]
inputData = zip [1..] rawData

----------

lowCutoffFrequency :: Double
lowCutoffFrequency = 40.0

highCutoffFrequency :: Double
highCutoffFrequency = 80.0

transBand :: Double
transBand = 10.0

filterDomain :: [Double]
filterDomain = [-(fromIntegral nof-1)/2 .. (fromIntegral nof-1)/2]
  where nof' = round $ 3.3 * fromIntegral numOfData / transBand
        nof = if odd nof' then nof' else nof'+1 :: Int

hamming :: Int -> Int -> Double -> Double
hamming n i v = v * (0.53836 - 0.46164 * cos((2.0 * pi * fromIntegral i) / (fromIntegral n - 1)));

lowPass :: [Double]
lowPass = zipWith (hamming (length filterDomain)) [1..] [ k * sinc (pi*k*n) | n <- filterDomain ]
  where k = 2 * lowCutoffFrequency / fromIntegral numOfData

lowPassedData :: [(Int, Double)]
lowPassedData = zip [1..] lpd
  where lpd = take numOfData $ drop (div (length filterDomain) 2) $ convolve lowPass rawData

highPass :: [Double]
highPass = zipWith (hamming (length filterDomain)) [1..] [ sinc (pi*n) - k * sinc (pi*k*n) | n <- filterDomain ]
  where k = 2 * highCutoffFrequency / fromIntegral numOfData

highPassedData :: [(Int, Double)]
highPassedData = zip [1..] hpd
  where hpd = take numOfData $ drop (div (length filterDomain) 2) $ convolve highPass rawData

bandPass :: [Double]
bandPass = zipWith (hamming (length filterDomain)) [1..] [ kh * sinc (pi*kh*n) - kl * sinc (pi*kl*n) | n <- filterDomain ]
  where kl = 2 * lowCutoffFrequency / fromIntegral numOfData
        kh = 2 * highCutoffFrequency / fromIntegral numOfData

bandPassedData :: [(Int, Double)]
bandPassedData = zip [1..] bpd
  where bpd = take numOfData $ drop (div (length filterDomain) 2) $ convolve bandPass rawData

bandStop :: [Double]
bandStop = zipWith (hamming (length filterDomain)) [1..] [ sinc (pi*n) - kh * sinc (pi*kh*n) + kl * sinc (pi*kl*n) | n <- filterDomain ]
  where kl = 2 * lowCutoffFrequency / fromIntegral numOfData
        kh = 2 * highCutoffFrequency / fromIntegral numOfData

bandStoppedData :: [(Int, Double)]
bandStoppedData = zip [1..] bsd
  where bsd = take numOfData $ drop (div (length filterDomain) 2) $ convolve bandStop rawData

----------

toDFT :: [(Int, Double)] -> [(Int, Complex Double)]
toDFT ds = take (div numOfData 2) $ assocs $ dft $ array (1, length ds) $ map (\(i, v) -> (i, v:+0)) ds

toAmplitude :: [(Int, Complex Double)] -> [(Int, Double)]
toAmplitude = map (second magnitude)

----------

timeChart :: Renderable ()
timeChart = toRenderable timeLayout
  where timeLayout = layout_title .~ "Time Scale Data"
                   $ layout_plots .~ [ toPlot inputLine ]
                   $ def

        inputLine = plot_lines_title .~ "Input Data"
                  $ plot_lines_style . line_color .~ opaque skyblue
                  $ plot_lines_values .~ [inputData]
                  $ def

timeChartLowPass :: Renderable ()
timeChartLowPass = toRenderable timeLayoutLowPass
  where timeLayoutLowPass = layout_title .~ "Time Scale Data(Low Pass)"
                          $ layout_plots .~ [ toPlot inputLine
                                            , toPlot lowPassLine ]
                          $ def

        inputLine = plot_lines_title .~ "Input Data"
                  $ plot_lines_style . line_color .~ opaque skyblue
                  $ plot_lines_values .~ [inputData]
                  $ def

        lowPassLine = plot_lines_title .~ "Low Passed Data"
                    $ plot_lines_style . line_color .~ opaque green
                    $ plot_lines_values .~ [lowPassedData]
                    $ def

timeChartHighPass :: Renderable ()
timeChartHighPass = toRenderable timeLayoutHighPass
  where timeLayoutHighPass = layout_title .~ "Time Scale Data(High Pass)"
                           $ layout_plots .~ [ toPlot inputLine
                                             , toPlot highPassLine ]
                           $ def

        inputLine = plot_lines_title .~ "Input Data"
                  $ plot_lines_style . line_color .~ opaque skyblue
                  $ plot_lines_values .~ [inputData]
                  $ def

        highPassLine = plot_lines_title .~ "High Passed Data"
                     $ plot_lines_style . line_color .~ opaque orange
                     $ plot_lines_values .~ [highPassedData]
                     $ def

timeChartBandPass :: Renderable ()
timeChartBandPass = toRenderable timeLayoutBandPass
  where timeLayoutBandPass = layout_title .~ "Time Scale Data(Band Pass)"
                           $ layout_plots .~ [ toPlot inputLine
                                             , toPlot bandPassLine ]
                           $ def

        inputLine = plot_lines_title .~ "Input Data"
                  $ plot_lines_style . line_color .~ opaque skyblue
                  $ plot_lines_values .~ [inputData]
                  $ def

        bandPassLine = plot_lines_title .~ "Band Passed Data"
                     $ plot_lines_style . line_color .~ opaque purple
                     $ plot_lines_values .~ [bandPassedData]
                     $ def

timeChartBandStop :: Renderable ()
timeChartBandStop = toRenderable timeLayoutBandStop
  where timeLayoutBandStop = layout_title .~ "Time Scale Data(Band Stop)"
                           $ layout_plots .~ [ toPlot inputLine
                                             , toPlot bandStopLine ]
                           $ def

        inputLine = plot_lines_title .~ "Input Data"
                  $ plot_lines_style . line_color .~ opaque skyblue
                  $ plot_lines_values .~ [inputData]
                  $ def

        bandStopLine = plot_lines_title .~ "Band Stopped Data"
                     $ plot_lines_style . line_color .~ opaque royalblue
                     $ plot_lines_values .~ [bandStoppedData]
                     $ def

frequencyChart :: Renderable ()
frequencyChart = toRenderable frequencyLayout
  where frequencyLayout = layout_title .~ "Frequency Scale Data"
                        $ layout_y_axis .~ yAxis'
                        $ layout_plots .~ [ toPlot inputLine' ]
                        $ def

        yAxis' = laxis_title .~ "Amplitude"
               $ def

        inputLine' = plot_lines_title .~ "Input Data"
                   $ plot_lines_style . line_color .~ opaque skyblue
                   $ plot_lines_values .~ [toAmplitude $ toDFT inputData]
                   $ def

frequencyChartLowPass :: Renderable ()
frequencyChartLowPass = toRenderable frequencyLayoutLowPass
  where frequencyLayoutLowPass = layout_title .~ "Frequency Scale Data(Low Pass)"
                               $ layout_y_axis .~ yAxis'
                               $ layout_plots .~ [ toPlot inputLine'
                                                 , toPlot lowPassLine' ]
                               $ def

        yAxis' = laxis_title .~ "Amplitude"
               $ def

        inputLine' = plot_lines_title .~ "Input Data"
                   $ plot_lines_style . line_color .~ opaque skyblue
                   $ plot_lines_values .~ [toAmplitude $ toDFT inputData]
                   $ def

        lowPassLine' = plot_lines_title .~ "Low Passed Data"
                     $ plot_lines_style . line_color .~ opaque green
                     $ plot_lines_values .~ [toAmplitude $ toDFT lowPassedData]
                     $ def

frequencyChartHighPass :: Renderable ()
frequencyChartHighPass = toRenderable frequencyLayoutHighPass
  where frequencyLayoutHighPass = layout_title .~ "Frequency Scale Data(High Pass)"
                                $ layout_y_axis .~ yAxis'
                                $ layout_plots .~ [ toPlot inputLine'
                                                  , toPlot highPassLine' ]
                                $ def

        yAxis' = laxis_title .~ "Amplitude"
               $ def

        inputLine' = plot_lines_title .~ "Input Data"
                   $ plot_lines_style . line_color .~ opaque skyblue
                   $ plot_lines_values .~ [toAmplitude $ toDFT inputData]
                   $ def

        highPassLine' = plot_lines_title .~ "High Passed Data"
                      $ plot_lines_style . line_color .~ opaque orange
                      $ plot_lines_values .~ [toAmplitude $ toDFT highPassedData]
                      $ def

frequencyChartBandPass :: Renderable ()
frequencyChartBandPass = toRenderable frequencyLayoutBandPass
  where frequencyLayoutBandPass = layout_title .~ "Frequency Scale Data(Band Pass)"
                                $ layout_y_axis .~ yAxis'
                                $ layout_plots .~ [ toPlot inputLine'
                                                  , toPlot bandPassLine' ]
                                $ def

        yAxis' = laxis_title .~ "Amplitude"
               $ def

        inputLine' = plot_lines_title .~ "Input Data"
                   $ plot_lines_style . line_color .~ opaque skyblue
                   $ plot_lines_values .~ [toAmplitude $ toDFT inputData]
                   $ def

        bandPassLine' = plot_lines_title .~ "Band Passed Data"
                      $ plot_lines_style . line_color .~ opaque purple
                      $ plot_lines_values .~ [toAmplitude $ toDFT bandPassedData]
                      $ def

frequencyChartBandStop :: Renderable ()
frequencyChartBandStop = toRenderable frequencyLayoutBandStop
  where frequencyLayoutBandStop = layout_title .~ "Frequency Scale Data(Band Stop)"
                                $ layout_y_axis .~ yAxis'
                                $ layout_plots .~ [ toPlot inputLine'
                                                  , toPlot bandStopLine' ]
                                $ def

        yAxis' = laxis_title .~ "Amplitude"
               $ def

        inputLine' = plot_lines_title .~ "Input Data"
                   $ plot_lines_style . line_color .~ opaque skyblue
                   $ plot_lines_values .~ [toAmplitude $ toDFT inputData]
                   $ def

        bandStopLine' = plot_lines_title .~ "Band Stopped Data"
                      $ plot_lines_style . line_color .~ opaque royalblue
                      $ plot_lines_values .~ [toAmplitude $ toDFT bandStoppedData]
                      $ def

----------

decode :: Either String DynamicImage -> IO (Image PixelRGB8)
decode (Right (ImageRGB8 image)) = return image
decode _ = throwIO $ userError "Image Parse Error"

----------

main :: IO ()
main = do
  _ <- renderableToFile def "./png/time_scale_1.png" timeChart
  _ <- renderableToFile def "./png/time_scale_2.png" timeChartLowPass
  _ <- renderableToFile def "./png/time_scale_3.png" timeChartBandPass
  _ <- renderableToFile def "./png/time_scale_4.png" timeChartHighPass
  _ <- renderableToFile def "./png/time_scale_5.png" timeChartBandStop
  _ <- renderableToFile def "./png/freq_scale_1.png" frequencyChart
  _ <- renderableToFile def "./png/freq_scale_2.png" frequencyChartLowPass
  _ <- renderableToFile def "./png/freq_scale_3.png" frequencyChartBandPass
  _ <- renderableToFile def "./png/freq_scale_4.png" frequencyChartHighPass
  _ <- renderableToFile def "./png/freq_scale_5.png" frequencyChartBandStop

  timeScaleImages <- sequence [ readImage ("./png/time_scale_" ++ show i ++ ".png") >>= decode | i <- [1..5] ]
  freqScaleImages <- sequence [ readImage ("./png/freq_scale_" ++ show i ++ ".png") >>= decode | i <- [1..5] ]

  either putStrLn id $ writeGifAnimation "time_scale.gif" 100 LoopingForever timeScaleImages
  either putStrLn id $ writeGifAnimation "freq_scale.gif" 100 LoopingForever freqScaleImages

max_stars_repo_name: IMOKURI/fast-fourier-transform-example

max_issues_repo_name: IMOKURI/fast-fourier-transform-example

max_forks_repo_name: IMOKURI/fast-fourier-transform-example


text:
module Utilities.Types where
import           Data.Complex
import qualified System.IO                     as IO
import           Data.Ratio
import           Data.Array
import           Data.IORef
import           Control.Monad.Except
import           Text.ParserCombinators.Parsec
                                         hiding ( spaces )

type Env = IORef [(String, IORef LispVal)]
type ThrowsError = Either LispError
type IOThrowsError = ExceptT LispError IO

data LispError = NumArgs Integer [LispVal]
    | TypeMismatch String LispVal
    | Parser ParseError
    | BadSpecialForm String LispVal
    | NotFunction String String
    | UnboundVar String String
    | Default String

data LispVal = Atom String
    | List [LispVal]
    | DottedList [LispVal] LispVal
    | Number Integer
    | String String
    | Bool Bool
    | Character Char
    | Float Double
    | Ratio Rational
    | Complex (Complex Double)
    | Vector (Array Int LispVal)
    | PrimitiveFunc ([LispVal] -> ThrowsError LispVal)
    | Func {params :: [String], vararg :: Maybe String,
        body :: [LispVal], closure :: Env}
    | IOFunc ([LispVal] -> IOThrowsError LispVal)
    | Port IO.Handle
    | None

showVal :: LispVal -> String
showVal val = case val of
    String contents -> "\"" ++ contents ++ "\""
    Atom   name     -> name
    Number contents -> show contents
    Bool   True     -> "#t"
    Bool   False    -> "#f"
    List   contents -> "(" ++ unwordsList contents ++ ")"
    DottedList head tail ->
        "(" ++ unwordsList head ++ " . " ++ showVal tail ++ ")"
    PrimitiveFunc _ -> "<primitive"
    Func { params = args, vararg = varargs, body = body, closure = env } ->
        "(lambda ("
            ++ unwords (map show args)
            ++ (case varargs of
                   Nothing  -> ""
                   Just arg -> " . " ++ arg
               )
            ++ ") ...)"
    Port   _ -> "<IO port>"
    IOFunc _ -> "<IO primitive>"

instance Show LispVal where
    show = showVal
instance Eq LispVal where
    (==) = (==)

unwordsList :: [LispVal] -> String
unwordsList = unwords . map showVal

max_stars_repo_name: jordanosborn/Haskell-Lisp

max_issues_repo_name: jordanosborn/Haskell-Lisp

max_forks_repo_name: jordanosborn/Haskell-Lisp