diff --git a/pregame.cabal b/pregame.cabal
--- a/pregame.cabal
+++ b/pregame.cabal
@@ -1,7 +1,7 @@
 name:
   pregame
 version:
-  1.0.0.0
+  1.0.0.1
 synopsis:
   Prelude for applications
 description:
@@ -33,6 +33,25 @@
 library
   exposed-modules:
     Pregame
+  other-modules:
+    Pregame.Aeson
+    Pregame.Array
+    Pregame.Base
+    Pregame.Bytestring
+    Pregame.Containers
+    Pregame.DataDefault
+    Pregame.Deepseq
+    Pregame.Either
+    Pregame.GhcPrim
+    Pregame.IntegerGmp
+    Pregame.Lens
+    Pregame.Mtl
+    Pregame.Safe
+    Pregame.Stm
+    Pregame.Text
+    Pregame.Time
+    Pregame.UnorderedContainers
+    Pregame.Vector
   default-extensions:
     NoImplicitPrelude
   build-depends:
diff --git a/src/Pregame/Aeson.hs b/src/Pregame/Aeson.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Aeson.hs
@@ -0,0 +1,31 @@
+module Pregame.Aeson
+  ( module X
+  , noPrefixDeriveOptions
+  , tailDeriveOptions
+  ) where
+
+import Data.Aeson as X
+  ( ToJSON
+  , FromJSON
+  )
+import Data.Aeson.TH as X
+  ( deriveJSON
+  )
+
+import Data.Aeson.Types
+  ( defaultOptions
+  , Options(fieldLabelModifier)
+  )
+import Pregame.Base
+
+noPrefixDeriveOptions :: String -> Options
+noPrefixDeriveOptions prefix = defaultOptions
+  { fieldLabelModifier = lowerFirstChar . drop (length prefix)
+  }
+  where
+    lowerFirstChar :: String -> String
+    lowerFirstChar [] = []
+    lowerFirstChar (x:xs) = toLower x : xs
+
+tailDeriveOptions :: Options
+tailDeriveOptions = defaultOptions { fieldLabelModifier = drop 1 }
diff --git a/src/Pregame/Array.hs b/src/Pregame/Array.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Array.hs
@@ -0,0 +1,29 @@
+module Pregame.Array
+  ( module X
+  ) where
+
+import Data.Array as X
+  ( Array
+  )
+import Data.Array.IArray as X
+  ( IArray
+  )
+import Data.Array.IO as X
+  ( IOArray
+  , IOUArray
+  , hGetArray
+  , hPutArray
+  )
+import Data.Array.ST as X
+  ( STArray
+  , STUArray
+  )
+import Data.Array.MArray as X
+  ( MArray
+  )
+import Data.Array.Storable as X
+  ( StorableArray
+  )
+import Data.Array.Unboxed as X
+  ( UArray
+  )
diff --git a/src/Pregame/Base.hs b/src/Pregame/Base.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Base.hs
@@ -0,0 +1,380 @@
+{-# LANGUAGE BangPatterns #-}
+module Pregame.Base
+  ( module X
+  , done
+  , ($!)
+  ) where
+
+import Control.Category as X
+  ( Category(id, (.))
+  , (<<<)
+  , (>>>)
+  )
+import Data.Function as X
+  ( ($)
+  , (&)
+  , const
+  , flip
+  , fix
+  )
+import Data.Bool as X
+  ( Bool(True, False)
+  , (&&)
+  , (||)
+  , not
+  , otherwise
+  )
+import Data.Bifunctor as X
+  ( Bifunctor(bimap, first, second)
+  )
+import Data.Bits as X
+  ( Bits
+  )
+import Data.Int as X
+  ( Int8
+  , Int16
+  , Int32
+  , Int64
+  )
+import Data.Char as X
+  ( isSpace
+  , isLower
+  , isUpper
+  , isAlpha
+  , isAlphaNum
+  , isDigit
+  , isOctDigit
+  , isHexDigit
+  , isLetter
+  , toLower
+  , toUpper
+  )
+import Data.Word as X
+  ( Word8
+  , Word16
+  , Word32
+  , Word64
+  )
+import Data.String as X
+  ( String
+  , IsString
+  )
+import Foreign.C.Types as X
+  ( CChar(CChar)
+  , CSChar(CSChar)
+  , CUChar(CUChar)
+  , CShort(CShort)
+  , CUShort(CUShort)
+  , CInt(CInt)
+  , CUInt(CUInt)
+  , CLong(CLong)
+  , CULong(CULong)
+  , CPtrdiff(CPtrdiff)
+  , CSize(CSize)
+  , CWchar(CWchar)
+  , CSigAtomic(CSigAtomic)
+  , CLLong(CLLong)
+  , CULLong(CULLong)
+  , CIntPtr(CIntPtr)
+  , CUIntPtr(CUIntPtr)
+  , CIntMax(CIntMax)
+  , CUIntMax(CUIntMax)
+  , CClock(CClock)
+  , CTime(CTime)
+  , CUSeconds(CUSeconds)
+  , CSUSeconds(CSUSeconds)
+  , CFloat(CFloat)
+  , CDouble(CDouble)
+  , CFile
+  , CFpos
+  , CJmpBuf
+  )
+import Foreign.Ptr as X
+  ( Ptr
+  , nullPtr
+  , castPtr
+  , plusPtr
+  , alignPtr
+  , minusPtr
+  , FunPtr
+  , nullFunPtr
+  , castFunPtr
+  , castFunPtrToPtr
+  , castPtrToFunPtr
+  , IntPtr
+  , ptrToIntPtr
+  , intPtrToPtr
+  , WordPtr
+  , ptrToWordPtr
+  , wordPtrToPtr
+  )
+import Foreign.Storable as X
+  ( Storable
+  , sizeOf
+  , alignment
+  , peekElemOff
+  , pokeElemOff
+  , peekByteOff
+  , pokeByteOff
+  , peek
+  , poke
+  )
+import Data.Void as X
+  ( Void
+  )
+import Data.Ord as X
+  ( Ord
+  , compare
+  , (<=)
+  , (>=)
+  , (<)
+  , (>)
+  )
+import Data.Proxy as X
+  ( Proxy(Proxy)
+  )
+import GHC.Enum as X
+  ( Enum
+  , Bounded(minBound, maxBound)
+  )
+import GHC.Num as X
+  ( Num(..)
+  )
+import Data.Fixed as X
+  ( div'
+  , mod'
+  , divMod'
+  , Fixed(MkFixed)
+  , HasResolution
+  )
+import GHC.Real as X
+  ( Real(..)
+  , Integral(..)
+  , Fractional(..)
+  , Ratio(..)
+  , (^)
+  , (^^)
+  , fromIntegral
+  , realToFrac
+  )
+import Data.Eq as X
+  ( Eq((==))
+  )
+import Data.Monoid as X
+  ( Monoid
+  , mempty
+  , mappend
+  , mconcat
+  , Dual(Dual)
+  , Endo(Endo)
+  , All(All)
+  , Any(Any)
+  , Sum(Sum)
+  , Product(Product)
+  , First(First)
+  , Last(Last)
+  , Alt(Alt)
+  )
+import Data.Semigroup as X
+  ( Semigroup
+  , (<>)
+  , sconcat
+  )
+import Data.Functor as X
+  ( Functor
+  , fmap
+  , ($>)
+  , (<$>)
+  , void
+  )
+import Data.Foldable as X
+  ( Foldable
+  , foldMap
+  , foldr
+  , foldl'
+  , null
+  , length
+  , elem
+  , foldrM
+  , foldlM
+  , traverse_
+  , for_
+  , sequenceA_
+  , asum
+  , mapM_
+  , forM_
+  , sequence_
+  , msum
+  , concat
+  , concatMap
+  , and
+  , or
+  , any
+  , all
+  , notElem
+  , find
+  )
+import Data.Tuple as X
+  ( fst
+  , snd
+  )
+import GHC.List as X
+  ( map
+  , (++)
+  , filter
+  , cycle
+  , replicate
+  , repeat
+  , iterate
+  , drop
+  , take
+  )
+import Data.List.NonEmpty as X
+  ( NonEmpty((:|))
+  , nonEmpty
+  )
+import Control.Applicative as X
+  ( Applicative
+  , pure
+  , (<*>)
+  , Alternative
+  , (<|>)
+  , some
+  , many
+  )
+import Control.Exception as X
+  ( SomeException
+  , IOException
+  )
+import Data.Maybe as X
+  ( Maybe(Just, Nothing)
+  , maybe
+  , fromMaybe
+  , isJust
+  , isNothing
+  , catMaybes
+  )
+import Data.Either as X
+  ( Either(Left, Right)
+  , either
+  , lefts
+  , rights
+  , isLeft
+  , isRight
+  , partitionEithers
+  )
+import Data.Traversable as X
+  ( Traversable
+  , traverse
+  , sequenceA
+  , mapM
+  , sequence
+  , for
+  , forM
+  , mapAccumL
+  , mapAccumR
+  )
+import Control.Monad as X
+  ( Monad
+  , return
+  , (>>=)
+  , MonadPlus
+  , mzero
+  , mplus
+  , join
+  , (>>)
+  , (=<<)
+  , (>=>)
+  , (<=<)
+  , forever
+  , guard
+  , when
+  , unless
+  )
+import Control.Monad.Fix as X
+  ( MonadFix
+  , mfix
+  )
+import GHC.IORef as X
+  ( IORef
+  , newIORef
+  , readIORef
+  , writeIORef
+  , atomicModifyIORef
+  )
+import Control.Concurrent.MVar as X
+  ( MVar
+  , newMVar
+  , newEmptyMVar
+  , readMVar
+  , putMVar
+  , takeMVar
+  , modifyMVar
+  )
+import Control.Concurrent.Chan as X
+  ( Chan
+  , newChan
+  , readChan
+  , writeChan
+  , dupChan
+  )
+import System.Posix.Types
+  ( CDev(CDev)
+  , CIno(CIno)
+  , CMode(CMode)
+  , COff(COff)
+  , CPid(CPid)
+  , CSsize(CSsize)
+  , CGid(CGid)
+  , CNlink(CNlink)
+  , CUid(CUid)
+  , CCc(CCc)
+  , CSpeed(CSpeed)
+  , CTcflag(CTcflag)
+  , CRLim(CRLim)
+  , Fd(Fd)
+  , LinkCount
+  , UserID
+  , GroupID
+  , ByteCount
+  , ClockTick
+  , EpochTime
+  , FileOffset
+  , ProcessID
+  , DeviceID
+  , FileID
+  , FileMode
+  , Limit
+  )
+import System.IO as X
+  ( fixIO
+  , FilePath
+  , Handle
+  , stdin
+  , stdout
+  , stderr
+  , withFile
+  , openFile
+  , IOMode(ReadMode, WriteMode, AppendMode, ReadWriteMode)
+  , hClose
+  , hIsOpen
+  , hIsClosed
+  , hIsReadable
+  , hIsWritable
+  )
+import Text.Read as X
+  ( Read
+  )
+import Text.Show as X
+  ( Show(show)
+  )
+import GHC.Generics as X
+  ( Generic
+  )
+
+done :: Monad m => m ()
+done = return ()
+
+infixr 0 $!
+($!) :: (a -> b) -> a -> b
+x $! y = let !y' = y in x y'
diff --git a/src/Pregame/Bytestring.hs b/src/Pregame/Bytestring.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Bytestring.hs
@@ -0,0 +1,12 @@
+module Pregame.Bytestring
+  ( module X
+  , LazyByteString
+  ) where
+
+import Data.ByteString as X
+  ( ByteString
+  )
+
+import qualified Data.ByteString.Lazy as Lazy (ByteString)
+
+type LazyByteString = Lazy.ByteString
diff --git a/src/Pregame/Containers.hs b/src/Pregame/Containers.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Containers.hs
@@ -0,0 +1,32 @@
+module Pregame.Containers
+  ( module X
+  ) where
+
+import Data.Graph as X
+  ( Graph
+  , Table
+  , Bounds
+  , Edge
+  , Vertex
+  )
+import Data.Map as X
+  ( Map
+  )
+import Data.Sequence as X
+  ( Seq
+  )
+import Data.IntSet as X
+  ( IntSet
+  )
+import Data.Set as X
+  ( Set
+  )
+import Data.Tree as X
+  ( Tree
+  , Forest
+  )
+import qualified Data.Map.Strict as Strict (Map)
+import qualified Data.IntMap.Strict as Strict (IntMap)
+
+type StrictMap = Strict.Map
+type StrictIntMap = Strict.IntMap
diff --git a/src/Pregame/DataDefault.hs b/src/Pregame/DataDefault.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/DataDefault.hs
@@ -0,0 +1,8 @@
+module Pregame.DataDefault
+  ( module X
+  ) where
+
+import Data.Default as X
+  ( Default
+  , def
+  )
diff --git a/src/Pregame/Deepseq.hs b/src/Pregame/Deepseq.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Deepseq.hs
@@ -0,0 +1,8 @@
+module Pregame.Deepseq
+  ( module X
+  ) where
+
+import Control.DeepSeq as X
+  ( NFData
+  , deepseq
+  )
diff --git a/src/Pregame/Either.hs b/src/Pregame/Either.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Either.hs
@@ -0,0 +1,20 @@
+module Pregame.Either
+  ( module X
+  , maybeToLeft
+  , maybeToRight
+  ) where
+
+import Data.Either.Combinators as X
+  ( leftToMaybe
+  , rightToMaybe
+  )
+
+import Pregame.Base
+
+maybeToLeft :: b -> Maybe a -> Either a b
+maybeToLeft _ (Just x) = Left x
+maybeToLeft y Nothing  = Right y
+
+maybeToRight :: b -> Maybe a -> Either b a
+maybeToRight _ (Just x) = Right x
+maybeToRight y Nothing  = Left y
diff --git a/src/Pregame/GhcPrim.hs b/src/Pregame/GhcPrim.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/GhcPrim.hs
@@ -0,0 +1,14 @@
+module Pregame.GhcPrim
+  ( module X
+  ) where
+
+import GHC.Types as X
+  ( Bool(False, True)
+  , Char
+  , Int
+  , Word
+  , Float
+  , Double
+  , Ordering(LT, GT, EQ)
+  , IO
+  )
diff --git a/src/Pregame/IntegerGmp.hs b/src/Pregame/IntegerGmp.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/IntegerGmp.hs
@@ -0,0 +1,7 @@
+module Pregame.IntegerGmp
+  ( module X
+  ) where
+
+import GHC.Integer as X
+  ( Integer
+  )
diff --git a/src/Pregame/Lens.hs b/src/Pregame/Lens.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Lens.hs
@@ -0,0 +1,27 @@
+module Pregame.Lens
+  ( module X
+  ) where
+
+import Control.Lens as X
+  ( Lens
+  , Lens'
+  , makeLenses
+  , lens
+  , _1
+  , _2
+  , _3
+  , _4
+  , _5
+  , _6
+  , _7
+  , _8
+  , _9
+  , to
+  , (^.)
+  , set
+  , (.~)
+  , over
+  , (%~)
+  , view
+  , use
+  )
diff --git a/src/Pregame/Mtl.hs b/src/Pregame/Mtl.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Mtl.hs
@@ -0,0 +1,110 @@
+module Pregame.Mtl
+  ( module X
+  , io
+  ) where
+
+import Control.Monad.Reader as X
+  ( MonadReader
+  , ask
+  , reader
+  , asks
+  , ReaderT
+  , runReaderT
+  , mapReaderT
+  , withReaderT
+  , Reader
+  , runReader
+  , mapReader
+  , withReader
+  )
+import Control.Monad.State as X
+  ( MonadState
+  , get
+  , put
+  , state
+  , modify
+  , modify'
+  , gets
+  , StateT
+  , runStateT
+  , evalStateT
+  , execStateT
+  , mapStateT
+  , withStateT
+  , State
+  , runState
+  , evalState
+  , execState
+  , mapState
+  , withState
+  )
+import Control.Monad.Writer as X
+  ( MonadWriter
+  , writer
+  , tell
+  , WriterT
+  , runWriterT
+  , execWriterT
+  , mapWriterT
+  , Writer
+  , runWriter
+  , execWriter
+  , mapWriter
+  )
+import Control.Monad.RWS as X
+  ( MonadRWS
+  , RWST
+  , runRWST
+  , evalRWST
+  , execRWST
+  , mapRWST
+  , withRWST
+  , RWS
+  , rws
+  , runRWS
+  , evalRWS
+  , execRWS
+  , mapRWS
+  , withRWS
+  )
+import Control.Monad.Trans as X
+  ( MonadTrans
+  , lift
+  , MonadIO
+  , liftIO
+  )
+import Control.Monad.List as X
+  ( ListT
+  , runListT
+  , mapListT
+  )
+import Control.Monad.Except as X
+  ( MonadError
+  , throwError
+  , catchError
+  , ExceptT
+  , runExceptT
+  , mapExceptT
+  , withExceptT
+  , Except
+  , runExcept
+  , mapExcept
+  , withExcept
+  )
+import Control.Monad.Cont as X
+  ( MonadCont
+  , callCC
+  , ContT
+  , runContT
+  , mapContT
+  , withContT
+  , Cont
+  , cont
+  , runCont
+  , mapCont
+  , withCont
+  )
+import Pregame.GhcPrim
+
+io :: MonadIO m => IO a -> m a
+io = liftIO
diff --git a/src/Pregame/Safe.hs b/src/Pregame/Safe.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Safe.hs
@@ -0,0 +1,27 @@
+module Pregame.Safe
+  ( module X
+  ) where
+
+import Safe as X
+  ( readMay
+  , tailMay
+  , headMay
+  , initMay
+  , lastMay
+  , minimumMay
+  , maximumMay
+  , foldr1May
+  , foldl1May'
+  , scanl1May
+  , scanr1May
+  , cycleMay
+  , atMay
+  , toEnumMay
+  )
+import Safe.Exact as X
+  ( takeExactMay
+  , dropExactMay
+  , splitAtExactMay
+  , zipExactMay
+  , zipWithExactMay
+  ) 
diff --git a/src/Pregame/Stm.hs b/src/Pregame/Stm.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Stm.hs
@@ -0,0 +1,31 @@
+module Pregame.Stm
+  ( module X
+  , writeTVarIO
+  , modifyTVarIO
+  , modifyTVarIO'
+  ) where
+
+import Control.Concurrent.STM as X
+  ( STM
+  , TVar
+  , atomically
+  , newTVar
+  , newTVarIO
+  , readTVar
+  , readTVarIO
+  , writeTVar
+  , modifyTVar
+  , modifyTVar'
+  , swapTVar
+  )
+
+import Pregame.GhcPrim
+
+writeTVarIO :: TVar a -> a -> IO ()
+writeTVarIO tvar a = atomically (writeTVar tvar a)
+
+modifyTVarIO :: TVar a -> (a -> a) -> IO ()
+modifyTVarIO tvar f = atomically (modifyTVar tvar f)
+
+modifyTVarIO' :: TVar a -> (a -> a) -> IO ()
+modifyTVarIO' tvar f = atomically (modifyTVar' tvar f)
diff --git a/src/Pregame/Text.hs b/src/Pregame/Text.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Text.hs
@@ -0,0 +1,31 @@
+module Pregame.Text
+  ( module X
+  , LazyText
+  ) where
+
+import Data.Text as X
+  ( Text
+  , pack
+  , unpack
+  , lines
+  , words
+  , unlines
+  , unwords
+  )
+import Data.Text.IO as X
+  ( hGetContents
+  , hGetLine
+  , hPutStr
+  , hPutStrLn
+  , readFile
+  , writeFile
+  , appendFile
+  , interact
+  , getContents
+  , getLine
+  , putStr
+  , putStrLn
+  )
+import qualified Data.Text.Lazy as Lazy (Text)
+
+type LazyText = Lazy.Text
diff --git a/src/Pregame/Time.hs b/src/Pregame/Time.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Time.hs
@@ -0,0 +1,12 @@
+module Pregame.Time
+  ( module X
+  ) where
+
+import Data.Time.Clock.POSIX as X
+  ( POSIXTime
+  , getPOSIXTime
+  )
+import Data.Time.Clock as X
+  ( UTCTime
+  , getCurrentTime
+  )
diff --git a/src/Pregame/UnorderedContainers.hs b/src/Pregame/UnorderedContainers.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/UnorderedContainers.hs
@@ -0,0 +1,14 @@
+module Pregame.UnorderedContainers
+  ( module X
+  , LazyHashMap
+  , StrictHashMap
+  ) where
+
+import Data.HashSet as X
+  ( HashSet
+  )
+import qualified Data.HashMap.Lazy as Lazy (HashMap)
+import qualified Data.HashMap.Strict as Strict (HashMap)
+
+type LazyHashMap = Lazy.HashMap
+type StrictHashMap = Strict.HashMap
diff --git a/src/Pregame/Vector.hs b/src/Pregame/Vector.hs
new file mode 100644
--- /dev/null
+++ b/src/Pregame/Vector.hs
@@ -0,0 +1,7 @@
+module Pregame.Vector
+  ( module X
+  ) where
+
+import Data.Vector as X
+  ( Vector
+  )