    {-# LANGUAGE CPP, Rank2Types, MagicHash, UnboxedTuples, ExistentialQuantification #-}
    {-# OPTIONS_GHC -fno-warn-unused-binds #-} -- SPEC2

    -- | Internal module, do not import or use.
    module Data.Generics.Uniplate.Internal.Utils(
        unsafeCoerce, builder, unsafePerformIO, inlinePerformIO, concatCont, SPEC(SPEC)
        ) where

    #if __GLASGOW_HASKELL__ >= 702
    import System.IO.Unsafe(unsafePerformIO)
    #else
    import Foreign(unsafePerformIO)
    #endif
    import Unsafe.Coerce(unsafeCoerce)

    #ifdef __GLASGOW_HASKELL__
    import GHC.Exts(build, realWorld#)
    #if __GLASGOW_HASKELL__ < 612
    import GHC.IOBase(IO(IO))
    #else
    import GHC.IO(IO(IO))
    #endif
    #endif

    #if __GLASGOW_HASKELL__ >= 701
    import GHC.Exts(SpecConstrAnnotation(..))
    #ifndef DEBIAN_NO_GHCI
    {-# ANN type SPEC ForceSpecConstr #-}
    #endif
    #endif

    {-# INLINE builder #-}
    -- | GHCs @foldr@\/@build@ system, but on all platforms
    #ifdef __GLASGOW_HASKELL__
    builder :: forall a . (forall b . (a -> b -> b) -> b -> b) -> [a]
    builder :: (forall b. (a -> b -> b) -> b -> b) -> [a]
    builder = (forall b. (a -> b -> b) -> b -> b) -> [a]
    forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
    build
    #else
    builder :: ((x -> [x] -> [x]) -> [x] -> [x]) -> [x]
    builder f = f (:) []
    #endif

    {-# INLINE inlinePerformIO #-}
    -- | 'unsafePerformIO', but suitable for inlining. Copied from "Data.ByteString.Base".
    inlinePerformIO :: IO a -> a
    #ifdef __GLASGOW_HASKELL__
    inlinePerformIO :: IO a -> a
    inlinePerformIO (IO m :: State# RealWorld -> (# State# RealWorld, a #)
    m) = case State# RealWorld -> (# State# RealWorld, a #)
    m State# RealWorld
    realWorld# of (# _, r :: a
    r #) -> a
    r
    #else
    inlinePerformIO = unsafePerformIO
    #endif

    {-# INLINE concatCont #-}
    -- | Perform concatentation of continuations
    concatCont :: [a -> a] -> a -> a
    concatCont :: [a -> a] -> a -> a
    concatCont xs :: [a -> a]
    xs rest :: a
    rest = ((a -> a) -> a -> a) -> a -> [a -> a] -> a
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (a -> a) -> a -> a
    forall a b. (a -> b) -> a -> b
    ($) a
    rest [a -> a]
    xs

    -- | Constructor specialisation on newer GHC
    data SPEC = SPEC | SPEC2