content: -- |
  -- Module      : AOC.Prelude
  -- Copyright   : (c) Justin Le 2018
  -- License     : BSD3
  --
  -- Maintainer  : justin@jle.im
  -- Stability   : experimental
  -- Portability : non-portable
  --
  -- Custom Prelude while developing challenges.  Ideally, once challenges
  -- are completed, an import to this module would be replaced with explicit
  -- ones for future readers.
  --
  
  
  module AOC.Prelude (
      module P
    ) where
  
  import           AOC.Common                 as P
  import           AOC.Common.Point           as P
  import           AOC.Solver                 as P
  import           AOC.Util                   as P
  import           Control.Applicative        as P
  import           Control.DeepSeq            as P
  import           Control.Lens               as P hiding (uncons, noneOf)
  import           Control.Monad              as P
  import           Control.Monad.Combinators  as P hiding (endBy, option, many, some)
  import           Control.Monad.Except       as P
  import           Control.Monad.State        as P
  import           Data.Bifunctor             as P
  import           Data.Char                  as P
  import           Data.Coerce                as P
  import           Data.Containers.ListUtils  as P
  import           Data.Either                as P
  import           Data.Finite                as P (Finite, packFinite, getFinite, modulo, finites)
  import           Data.Foldable              as P
  import           Data.Function              as P
  import           Data.Functor               as P
  import           Data.IntMap                as P (IntMap)
  import           Data.IntMap.NonEmpty       as P (NEIntMap)
  import           Data.IntSet                as P (IntSet)
  import           Data.IntSet.NonEmpty       as P (NEIntSet)
  import           Data.Ix                    as P hiding (index)
  import           Data.Kind                  as P
  import qualified Data.List                  as P
  import           Data.List.NonEmpty         as P (NonEmpty(..), nonEmpty)
  import           Data.List.Split            as P hiding (oneOf, sepBy)
  import           Data.Map                   as P (Map)
  import           Data.Map.NonEmpty          as P (NEMap)
  import           Data.Maybe                 as P
  import           Data.Ord                   as P
  import           Data.Semigroup             as P
  import           Data.Sequence              as P (Seq)
  import           Data.Set                   as P (Set)
  import           Data.Set.NonEmpty          as P (NESet)
  import           Data.Text                  as P (Text)
  import           Data.Text.Encoding         as P (encodeUtf8, decodeUtf8)
  import           Data.Time                  as P hiding (Day)
  import           Data.Traversable           as P
  import           Data.Tuple                 as P
  import           Data.Void                  as P
  import           Debug.Trace                as P
  import           GHC.Generics               as P (Generic)
  import           Linear                     as P (V1(..), V2(..), V3(..), V4(..), R1(..), R2(..), R3(..), R4(..))
  import           Numeric.Natural            as P
  import           System.IO.Unsafe           as P
  import           Text.Megaparsec            as P (try, eof, Parsec, oneOf, satisfy, anySingleBut, noneOf, anySingle)
  import           Text.Megaparsec.Char       as P (newline, space, space1, digitChar, binDigitChar, octDigitChar, hexDigitChar, asciiChar, char, string, string')
  import           Text.Megaparsec.Char.Lexer as P (decimal, binary, octal, hexadecimal, scientific, float, signed)
  import           Text.Printf                as P
  import           Text.Read                  as P (readMaybe)
  import           Unsafe.Coerce              as P
  
  import           Data.Generics.Labels ()
  