Haskell Hierarchical Libraries (base package)ContentsIndex
GHC.IOBase
Portability non-portable (GHC Extensions)
Stability internal
Maintainer cvs-ghc@haskell.org
Description
Definitions for the IO monad and its friends.
Synopsis
newtype IO a = IO (State# RealWorld -> (#State# RealWorld, a#))
unIO :: IO a -> State# RealWorld -> (#State# RealWorld, a#)
failIO :: String -> IO a
liftIO :: IO a -> State# RealWorld -> STret RealWorld a
bindIO :: IO a -> (a -> IO b) -> IO b
thenIO :: IO a -> IO b -> IO b
returnIO :: a -> IO a
stToIO :: ST RealWorld a -> IO a
ioToST :: IO a -> ST RealWorld a
unsafePerformIO :: IO a -> a
unsafeInterleaveIO :: IO a -> IO a
data MVar a = MVar (MVar# RealWorld a)
data Handle
= FileHandle FilePath !(MVar Handle__)
| DuplexHandle FilePath !(MVar Handle__) !(MVar Handle__)
type FD = Int
data Handle__ = Handle__ {
haFD :: !FD
haType :: HandleType
haIsBin :: Bool
haIsStream :: Bool
haBufferMode :: BufferMode
haBuffer :: !(IORef Buffer)
haBuffers :: !(IORef BufferList)
haOtherSide :: (Maybe (MVar Handle__))
}
type RawBuffer = MutableByteArray# RealWorld
data Buffer = Buffer {
bufBuf :: RawBuffer
bufRPtr :: !Int
bufWPtr :: !Int
bufSize :: !Int
bufState :: BufferState
}
data BufferState
= ReadBuffer
| WriteBuffer
data BufferList
= BufferListNil
| BufferListCons RawBuffer BufferList
bufferIsWritable :: Buffer -> Bool
bufferEmpty :: Buffer -> Bool
bufferFull :: Buffer -> Bool
data HandleType
= ClosedHandle
| SemiClosedHandle
| ReadHandle
| WriteHandle
| AppendHandle
| ReadWriteHandle
type FilePath = String
data BufferMode
= NoBuffering
| LineBuffering
| BlockBuffering (Maybe Int)
newtype IORef a = IORef (STRef RealWorld a)
newIORef :: a -> IO (IORef a)
readIORef :: IORef a -> IO a
writeIORef :: IORef a -> a -> IO ()
newtype IOArray i e = IOArray (STArray RealWorld i e)
newIOArray :: Ix i => (i, i) -> e -> IO (IOArray i e)
unsafeReadIOArray :: Ix i => IOArray i e -> Int -> IO e
unsafeWriteIOArray :: Ix i => IOArray i e -> Int -> e -> IO ()
readIOArray :: Ix i => IOArray i e -> i -> IO e
writeIOArray :: Ix i => IOArray i e -> i -> e -> IO ()
data Exception
= ArithException ArithException
| ArrayException ArrayException
| AssertionFailed String
| AsyncException AsyncException
| BlockedOnDeadMVar
| Deadlock
| DynException Dynamic
| ErrorCall String
| ExitException ExitCode
| IOException IOException
| NoMethodError String
| NonTermination
| PatternMatchFail String
| RecConError String
| RecSelError String
| RecUpdError String
data ArithException
= Overflow
| Underflow
| LossOfPrecision
| DivideByZero
| Denormal
data AsyncException
= StackOverflow
| HeapOverflow
| ThreadKilled
data ArrayException
= IndexOutOfBounds String
| UndefinedElement String
stackOverflow :: Exception
heapOverflow :: Exception
data ExitCode
= ExitSuccess
| ExitFailure Int
throw :: Exception -> a
throwIO :: Exception -> IO a
ioException :: IOException -> IO a
ioError :: IOError -> IO a
type IOError = IOException
data IOException = IOError {
ioe_handle :: (Maybe Handle)
ioe_type :: IOErrorType
ioe_location :: String
ioe_description :: String
ioe_filename :: (Maybe FilePath)
}
data IOErrorType
= AlreadyExists
| NoSuchThing
| ResourceBusy
| ResourceExhausted
| EOF
| IllegalOperation
| PermissionDenied
| UserError
| UnsatisfiedConstraints
| SystemError
| ProtocolError
| OtherError
| InvalidArgument
| InappropriateType
| HardwareFault
| UnsupportedOperation
| TimeExpired
| ResourceVanished
| Interrupted
| DynIOError Dynamic
userError :: String -> IOError
data IOMode
= ReadMode
| WriteMode
| AppendMode
| ReadWriteMode
Documentation
newtype IO a

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Constructors
IO (State# RealWorld -> (#State# RealWorld, a#))
Instances
MonadPlus IO
MonadError IOError IO
MonadFix IO
MonadIO IO
MArray IOArray e IO
MArray IOUArray Bool IO
MArray IOUArray Char IO
MArray IOUArray Int IO
MArray IOUArray Word IO
MArray IOUArray (Ptr a) IO
MArray IOUArray (FunPtr a) IO
MArray IOUArray Float IO
MArray IOUArray Double IO
MArray IOUArray (StablePtr a) IO
MArray IOUArray Int8 IO
MArray IOUArray Int16 IO
MArray IOUArray Int32 IO
MArray IOUArray Int64 IO
MArray IOUArray Word8 IO
MArray IOUArray Word16 IO
MArray IOUArray Word32 IO
MArray IOUArray Word64 IO
Storable e => MArray StorableArray e IO
Typeable a => Typeable (IO a)
Functor IO
Monad IO
unIO :: IO a -> State# RealWorld -> (#State# RealWorld, a#)
failIO :: String -> IO a
liftIO :: IO a -> State# RealWorld -> STret RealWorld a
bindIO :: IO a -> (a -> IO b) -> IO b
thenIO :: IO a -> IO b -> IO b
returnIO :: a -> IO a
stToIO :: ST RealWorld a -> IO a
A monad transformer embedding strict state transformers in the IO monad. The RealWorld parameter indicates that the internal state used by the ST computation is a special one supplied by the IO monad, and thus distinct from those used by invocations of runST.
ioToST :: IO a -> ST RealWorld a
unsafePerformIO :: IO a -> a

This is the "back door" into the IO monad, allowing IO computation to be performed at any time. For this to be safe, the IO computation should be free of side effects and independent of its environment.

If the I/O computation wrapped in unsafePerformIO performs side effects, then the relative order in which those side effects take place (relative to the main I/O trunk, or other calls to unsafePerformIO) is indeterminate. You have to be careful when writing and compiling modules that use unsafePerformIO:

  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Use {-# NOINLINE foo #-} as a pragu >unsafePerformIO: