shrughes

-- IMPORTANT: Any change made to L.hs is reverted when @undefine is called.
--            Edit Pristine.hs instead.
{-# LANGUAGE NoMonomorphismRestriction #-}
module L where
import Control.Applicative
import Control.Arrow
import Control.Arrow.Operations
import Control.Monad
import Control.Monad.Cont
import Control.Monad.Error
import Control.Monad.Fix
import Control.Monad.Identity
import Control.Monad.Instances
import Control.Monad.Logic
import Control.Monad.RWS
import Control.Monad.Reader
import Control.Monad.ST (ST, runST, fixST)
import Control.Monad.State
import Control.Monad.Writer
import Control.Parallel
import Control.Parallel.Strategies
import Data.Array
import Data.Bits
import Data.Bool
import Data.Char
import Data.Complex
import Data.Dynamic
import Data.Either
import Data.Eq
import Data.Fixed
import Data.Function hiding ((.))
import Data.Generics hiding (GT)
import Data.Graph
import Data.Int
import Data.Ix
import Data.List hiding ((++),map)
import Data.Maybe
import Data.Monoid
import Data.Number.BigFloat
import Data.Number.CReal
import Data.Number.Dif
import Data.Number.Fixed
import Data.Number.Interval
import Data.Number.Natural
import Data.Number.Symbolic
import Data.Ord
import Data.Ratio
import Data.STRef
import Data.Tree
import Data.Tuple
import Data.Typeable
import Data.Word
import Numeric
import ShowQ
import System.Random
import Text.PrettyPrint.HughesPJ hiding (empty)
import Text.Printf
import Text.Regex.Posix
import qualified Control.Arrow.Transformer as AT
import qualified Control.Arrow.Transformer.All as AT
import qualified Data.ByteString as BS
import qualified Data.ByteString.Char8 as BSC
import qualified Data.ByteString.Lazy as BSL
import qualified Data.ByteString.Lazy.Char8 as BSLC
import qualified Data.Foldable
import qualified Data.Generics
import qualified Data.IntMap as IM
import qualified Data.IntSet as IS
import qualified Data.Map as M
import qualified Data.Sequence
import qualified Data.Set as S
import qualified Data.Traversable
import qualified Data.Numbers
import qualified Data.Numbers.Primes

import SimpleReflect hiding (var)
import Math.OEIS

describeSequence = fmap description . lookupSequence

newtype Mu f = In { out :: f (Mu f) }

newtype Rec a = InR { outR :: Rec a -> a }

if' :: Bool -> a -> a -> a
if' p x y = if p then x else y

butt :: a
butt = error "shut up buttbot"

data Butt = Butt

instance Eq Butt where
  (==) = butt

instance Ord Butt where
  compare = butt

instance Enum Butt where
  toEnum = butt
  fromEnum = butt

instance Show Butt where
  show = butt

instance Num Butt where
  fromInteger = butt
  (+) = butt
  negate = butt
  (*) = butt
  abs = butt
  signum = butt

instance Real Butt where
  toRational = butt

instance Bounded Butt where
  minBound = butt
  maxBound = butt

instance Integral Butt where
  quotRem = butt
  toInteger = butt

instance Fractional Butt where
  fromRational = butt
  recip = butt

instance Floating Butt where
  pi = butt
  exp = butt
  log = butt
  sin = butt
  cos = butt
  sinh = butt
  cosh = butt
  asin = butt
  acos = butt
  atan = butt
  asinh = butt
  acosh = butt
  atanh = butt

instance RealFrac Butt where
  properFraction = butt

instance RealFloat Butt where
  floatRadix = butt
  floatDigits = butt
  floatRange = butt
  decodeFloat = butt
  encodeFloat = butt
  exponent = butt
  significand = butt
  scaleFloat = butt
  isNaN = butt
  isInfinite = butt
  isDenormalized = butt
  isNegativeZero = butt
  isIEEE = butt
  atan2 = butt

instance Bits Butt where
  (.&.) = butt
  (.|.) = butt
  xor = butt
  complement = butt
  shift = butt
  rotate = butt
  bitSize = butt
  isSigned = butt

{-# LINE 1 "<local>" #-}