    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE MagicHash #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE NoImplicitPrelude #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE UnboxedTuples #-}
    {-# LANGUAGE Unsafe #-}
    {-# LANGUAGE DeriveDataTypeable #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  GHC.Exts
    -- Copyright   :  (c) The University of Glasgow 2002
    -- License     :  see libraries/base/LICENSE
    --
    -- Maintainer  :  cvs-ghc@haskell.org
    -- Stability   :  internal
    -- Portability :  non-portable (GHC Extensions)
    --
    -- GHC Extensions: this is the Approved Way to get at GHC-specific extensions.
    --
    -- Note: no other base module should import this module.
    -----------------------------------------------------------------------------

    module GHC.Exts
           (
            -- * Representations of some basic types
            Int(..),Word(..),Float(..),Double(..),
            Char(..),
            Ptr(..), FunPtr(..),

            -- * The maximum tuple size
            maxTupleSize,

            -- * Primitive operations
            FUN, -- See https://gitlab.haskell.org/ghc/ghc/issues/18302
            module GHC.Prim,
            module GHC.Prim.Ext,
            shiftL#, shiftRL#, iShiftL#, iShiftRA#, iShiftRL#,
            isTrue#,
            Void#,  -- Previously exported by GHC.Prim

            -- * Compat wrapper
            atomicModifyMutVar#,

            -- * Resize functions
            --
            -- | Resizing arrays of boxed elements is currently handled in
            -- library space (rather than being a primop) since there is not
            -- an efficient way to grow arrays. However, resize operations
            -- may become primops in a future release of GHC.
            resizeSmallMutableArray#,

            -- * Fusion
            build, augment,

            -- * Overloaded string literals
            IsString(..),

            -- * CString
            unpackCString#,
            unpackAppendCString#,
            unpackFoldrCString#,
            unpackCStringUtf8#,
            unpackNBytes#,
            cstringLength#,

            -- * Debugging
            breakpoint, breakpointCond,

            -- * Ids with special behaviour
            inline, noinline, lazy, oneShot, considerAccessible, SPEC (..),

            -- * Running 'RealWorld' state thread
            runRW#,

            -- * Safe coercions
            --
            -- | These are available from the /Trustworthy/ module "Data.Coerce" as well
            --
            -- @since 4.7.0.0
            Data.Coerce.coerce, Data.Coerce.Coercible,

            -- * Very unsafe coercion
            unsafeCoerce#,

            -- * Equality
            type (~~),

            -- * Representation polymorphism
            GHC.Prim.TYPE, RuntimeRep(..), Levity(..),
            LiftedRep, UnliftedRep, UnliftedType,
            VecCount(..), VecElem(..),

            -- * Transform comprehensions
            Down(..), groupWith, sortWith, the,

            -- * Event logging
            traceEvent,

            -- * SpecConstr annotations
            SpecConstrAnnotation(..),

            -- * The call stack
            currentCallStack,

            -- * The Constraint kind
            Constraint,

            -- * The Any type
            Any,

            -- * Overloaded lists
            IsList(..)
           ) where

    import GHC.Prim hiding ( coerce, TYPE )
    import qualified GHC.Prim
    import qualified GHC.Prim.Ext
    import GHC.Base hiding ( coerce )
    import GHC.Ptr
    import GHC.Stack

    import qualified Data.Coerce
    import Data.String
    import Data.OldList
    import Data.Data
    import Data.Ord
    import Data.Version ( Version(..), makeVersion )
    import qualified Debug.Trace
    import Unsafe.Coerce ( unsafeCoerce# ) -- just for re-export

    import Control.Applicative (ZipList(..))

    -- XXX This should really be in Data.Tuple, where the definitions are
    maxTupleSize :: Int
    maxTupleSize :: Int
    maxTupleSize = Int
    64

    -- | 'the' ensures that all the elements of the list are identical
    -- and then returns that unique element
    the :: Eq a => [a] -> a
    the :: forall a. Eq a => [a] -> a
    the (a
    x:[a]
    xs)
      | (a -> Bool) -> [a] -> Bool
    forall a. (a -> Bool) -> [a] -> Bool
    all (a
    x a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) [a]
    xs = a
    x
      | Bool
    otherwise     = [Char] -> a
    forall a. [Char] -> a
    errorWithoutStackTrace [Char]
    "GHC.Exts.the: non-identical elements"
    the []            = [Char] -> a
    forall a. [Char] -> a
    errorWithoutStackTrace [Char]
    "GHC.Exts.the: empty list"

    -- | The 'sortWith' function sorts a list of elements using the
    -- user supplied function to project something out of each element
    sortWith :: Ord b => (a -> b) -> [a] -> [a]
    sortWith :: forall b a. Ord b => (a -> b) -> [a] -> [a]
    sortWith a -> b
    f = (a -> a -> Ordering) -> [a] -> [a]
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (\a
    x a
    y -> b -> b -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (a -> b
    f a
    x) (a -> b
    f a
    y))

    -- | The 'groupWith' function uses the user supplied function which
    -- projects an element out of every list element in order to first sort the
    -- input list and then to form groups by equality on these projected elements
    {-# INLINE groupWith #-}
    groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
    groupWith :: forall b a. Ord b => (a -> b) -> [a] -> [[a]]
    groupWith a -> b
    f [a]
    xs = (forall b. ([a] -> b -> b) -> b -> b) -> [[a]]
    forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
    build (\[a] -> b -> b
    c b
    n -> ([a] -> b -> b) -> b -> (a -> a -> Bool) -> [a] -> b
    forall a lst.
    ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst
    groupByFB [a] -> b -> b
    c b
    n (\a
    x a
    y -> a -> b
    f a
    x b -> b -> Bool
    forall a. Eq a => a -> a -> Bool
    == a -> b
    f a
    y) ((a -> b) -> [a] -> [a]
    forall b a. Ord b => (a -> b) -> [a] -> [a]
    sortWith a -> b
    f [a]
    xs))

    {-# INLINE [0] groupByFB #-} -- See Note [Inline FB functions] in GHC.List
    groupByFB :: ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst
    groupByFB :: forall a lst.
    ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst
    groupByFB [a] -> lst -> lst
    c lst
    n a -> a -> Bool
    eq [a]
    xs0 = [a] -> lst
    groupByFBCore [a]
    xs0
      where groupByFBCore :: [a] -> lst
    groupByFBCore [] = lst
    n
            groupByFBCore (a
    x:[a]
    xs) = [a] -> lst -> lst
    c (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    ys) ([a] -> lst
    groupByFBCore [a]
    zs)
                where ([a]
    ys, [a]
    zs) = (a -> Bool) -> [a] -> ([a], [a])
    forall a. (a -> Bool) -> [a] -> ([a], [a])
    span (a -> a -> Bool
    eq a
    x) [a]
    xs

    -- -----------------------------------------------------------------------------
    -- tracing

    traceEvent :: String -> IO ()
    traceEvent :: [Char] -> IO ()
    traceEvent = [Char] -> IO ()
    Debug.Trace.traceEventIO
    {-# DEPRECATED traceEvent "Use 'Debug.Trace.traceEvent' or 'Debug.Trace.traceEventIO'" #-} -- deprecated in 7.4

    {- **********************************************************************
    *                                                                       *
    *              SpecConstr annotation                                    *
    *                                                                       *
    ********************************************************************** -}

    -- Annotating a type with NoSpecConstr will make SpecConstr
    -- not specialise for arguments of that type.

    -- This data type is defined here, rather than in the SpecConstr module
    -- itself, so that importing it doesn't force stupidly linking the
    -- entire ghc package at runtime

    data SpecConstrAnnotation = NoSpecConstr | ForceSpecConstr
                    deriving ( Typeable SpecConstrAnnotation
    Typeable SpecConstrAnnotation
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g)
        -> SpecConstrAnnotation
        -> c SpecConstrAnnotation)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation)
    -> (SpecConstrAnnotation -> Constr)
    -> (SpecConstrAnnotation -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c SpecConstrAnnotation))
    -> ((forall b. Data b => b -> b)
        -> SpecConstrAnnotation -> SpecConstrAnnotation)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> SpecConstrAnnotation -> m SpecConstrAnnotation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> SpecConstrAnnotation -> m SpecConstrAnnotation)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> SpecConstrAnnotation -> m SpecConstrAnnotation)
    -> Data SpecConstrAnnotation
    SpecConstrAnnotation -> Constr
    SpecConstrAnnotation -> DataType
    (forall b. Data b => b -> b)
    -> SpecConstrAnnotation -> SpecConstrAnnotation
    forall a.
    Typeable a
    -> (forall (c :: * -> *).
        (forall d b. Data d => c (d -> b) -> d -> c b)
        -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u
    forall u.
    (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SpecConstrAnnotation
    -> c SpecConstrAnnotation
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SpecConstrAnnotation)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SpecConstrAnnotation -> m SpecConstrAnnotation
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u
    $cgmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u
    gmapQ :: forall u.
    (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u]
    $cgmapQ :: forall u.
    (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u]
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r
    gmapT :: (forall b. Data b => b -> b)
    -> SpecConstrAnnotation -> SpecConstrAnnotation
    $cgmapT :: (forall b. Data b => b -> b)
    -> SpecConstrAnnotation -> SpecConstrAnnotation
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SpecConstrAnnotation)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SpecConstrAnnotation)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation)
    dataTypeOf :: SpecConstrAnnotation -> DataType
    $cdataTypeOf :: SpecConstrAnnotation -> DataType
    toConstr :: SpecConstrAnnotation -> Constr
    $ctoConstr :: SpecConstrAnnotation -> Constr
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SpecConstrAnnotation
    -> c SpecConstrAnnotation
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> SpecConstrAnnotation
    -> c SpecConstrAnnotation
    Data -- ^ @since 4.3.0.0
                             , SpecConstrAnnotation -> SpecConstrAnnotation -> Bool
    (SpecConstrAnnotation -> SpecConstrAnnotation -> Bool)
    -> (SpecConstrAnnotation -> SpecConstrAnnotation -> Bool)
    -> Eq SpecConstrAnnotation
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool
    $c/= :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool
    == :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool
    $c== :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool
    Eq   -- ^ @since 4.3.0.0
                             )

    {- **********************************************************************
    *                                                                       *
    *              The IsList class                                         *
    *                                                                       *
    ********************************************************************** -}

    -- | The 'IsList' class and its methods are intended to be used in
    --   conjunction with the OverloadedLists extension.
    --
    -- @since 4.7.0.0
    class IsList l where
      -- | The 'Item' type function returns the type of items of the structure
      --   @l@.
      type Item l

      -- | The 'fromList' function constructs the structure @l@ from the given
      --   list of @Item l@
      fromList  :: [Item l] -> l

      -- | The 'fromListN' function takes the input list's length and potentially
      --   uses it to construct the structure @l@ more efficiently compared to
      --   'fromList'. If the given number does not equal to the input list's length
      --   the behaviour of 'fromListN' is not specified.
      --
      --   prop> fromListN (length xs) xs == fromList xs
      fromListN :: Int -> [Item l] -> l
      fromListN Int
    _ = [Item l] -> l
    forall l. IsList l => [Item l] -> l
    fromList

      -- | The 'toList' function extracts a list of @Item l@ from the structure @l@.
      --   It should satisfy fromList . toList = id.
      toList :: l -> [Item l]

    -- | @since 4.7.0.0
    instance IsList [a] where
      type (Item [a]) = a
      fromList :: [Item [a]] -> [a]
    fromList = [Item [a]] -> [a]
    forall a. a -> a
    id
      toList :: [a] -> [Item [a]]
    toList = [a] -> [Item [a]]
    forall a. a -> a
    id

    -- | @since 4.15.0.0
    instance IsList (ZipList a) where
      type Item (ZipList a) = a
      fromList :: [Item (ZipList a)] -> ZipList a
    fromList = [Item (ZipList a)] -> ZipList a
    forall a. [a] -> ZipList a
    ZipList
      toList :: ZipList a -> [Item (ZipList a)]
    toList = ZipList a -> [Item (ZipList a)]
    forall a. ZipList a -> [a]
    getZipList

    -- | @since 4.9.0.0
    instance IsList (NonEmpty a) where
      type Item (NonEmpty a) = a

      fromList :: [Item (NonEmpty a)] -> NonEmpty a
    fromList (Item (NonEmpty a)
    a:[Item (NonEmpty a)]
    as) = a
    Item (NonEmpty a)
    a a -> [a] -> NonEmpty a
    forall a. a -> [a] -> NonEmpty a
    :| [a]
    [Item (NonEmpty a)]
    as
      fromList [] = [Char] -> NonEmpty a
    forall a. [Char] -> a
    errorWithoutStackTrace [Char]
    "NonEmpty.fromList: empty list"

      toList :: NonEmpty a -> [Item (NonEmpty a)]
    toList ~(a
    a :| [a]
    as) = a
    a a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    : [a]
    as

    -- | @since 4.8.0.0
    instance IsList Version where
      type (Item Version) = Int
      fromList :: [Item Version] -> Version
    fromList = [Int] -> Version
    [Item Version] -> Version
    makeVersion
      toList :: Version -> [Item Version]
    toList = Version -> [Int]
    Version -> [Item Version]
    versionBranch

    -- | Be aware that 'fromList . toList = id' only for unfrozen 'CallStack's,
    -- since 'toList' removes frozenness information.
    --
    -- @since 4.9.0.0
    instance IsList CallStack where
      type (Item CallStack) = (String, SrcLoc)
      fromList :: [Item CallStack] -> CallStack
    fromList = [([Char], SrcLoc)] -> CallStack
    [Item CallStack] -> CallStack
    fromCallSiteList
      toList :: CallStack -> [Item CallStack]
    toList   = CallStack -> [([Char], SrcLoc)]
    CallStack -> [Item CallStack]
    getCallStack

    -- | An implementation of the old @atomicModifyMutVar#@ primop in
    -- terms of the new 'atomicModifyMutVar2#' primop, for backwards
    -- compatibility. The type of this function is a bit bogus. It's
    -- best to think of it as having type
    --
    -- @
    -- atomicModifyMutVar#
    --   :: MutVar# s a
    --   -> (a -> (a, b))
    --   -> State# s
    --   -> (# State# s, b #)
    -- @
    --
    -- but there may be code that uses this with other two-field record
    -- types.
    atomicModifyMutVar#
      :: MutVar# s a
      -> (a -> b)
      -> State# s
      -> (# State# s, c #)
    atomicModifyMutVar# :: forall s a b c.
    MutVar# s a -> (a -> b) -> State# s -> (# State# s, c #)
    atomicModifyMutVar# MutVar# s a
    mv a -> b
    f State# s
    s =
      case (# State# s, a, b #) -> (# State# s, Any, (Any, c) #)
    forall a b. a -> b
    unsafeCoerce# (MutVar# s a -> (a -> b) -> State# s -> (# State# s, a, b #)
    forall d a c.
    MutVar# d a -> (a -> c) -> State# d -> (# State# d, a, c #)
    atomicModifyMutVar2# MutVar# s a
    mv a -> b
    f State# s
    s) of
        (# State# s
    s', Any
    _, ~(Any
    _, c
    res) #) -> (# State# s
    s', c
    res #)

    -- | Resize a mutable array to new specified size. The returned
    -- 'SmallMutableArray#' is either the original 'SmallMutableArray#'
    -- resized in-place or, if not possible, a newly allocated
    -- 'SmallMutableArray#' with the original content copied over.
    --
    -- To avoid undefined behaviour, the original 'SmallMutableArray#' shall
    -- not be accessed anymore after a 'resizeSmallMutableArray#' has been
    -- performed. Moreover, no reference to the old one should be kept in order
    -- to allow garbage collection of the original 'SmallMutableArray#'  in
    -- case a new 'SmallMutableArray#' had to be allocated.
    --
    -- @since 4.14.0.0
    resizeSmallMutableArray#
      :: SmallMutableArray# s a -- ^ Array to resize
      -> Int# -- ^ New size of array
      -> a
         -- ^ Newly created slots initialized to this element.
         -- Only used when array is grown.
      -> State# s
      -> (# State# s, SmallMutableArray# s a #)
    resizeSmallMutableArray# :: forall s a.
    SmallMutableArray# s a
    -> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
    resizeSmallMutableArray# SmallMutableArray# s a
    arr0 Int#
    szNew a
    a State# s
    s0 =
      case SmallMutableArray# s a -> State# s -> (# State# s, Int# #)
    forall d a.
    SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
    getSizeofSmallMutableArray# SmallMutableArray# s a
    arr0 State# s
    s0 of
        (# State# s
    s1, Int#
    szOld #) -> if Int# -> Bool
    isTrue# (Int#
    szNew Int# -> Int# -> Int#
    <# Int#
    szOld)
          then case SmallMutableArray# s a -> Int# -> State# s -> State# s
    forall d a. SmallMutableArray# d a -> Int# -> State# d -> State# d
    shrinkSmallMutableArray# SmallMutableArray# s a
    arr0 Int#
    szNew State# s
    s1 of
            State# s
    s2 -> (# State# s
    s2, SmallMutableArray# s a
    arr0 #)
          else if Int# -> Bool
    isTrue# (Int#
    szNew Int# -> Int# -> Int#
    ># Int#
    szOld)
            then case Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
    forall a d.
    Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
    newSmallArray# Int#
    szNew a
    a State# s
    s1 of
              (# State# s
    s2, SmallMutableArray# s a
    arr1 #) -> case SmallMutableArray# s a
    -> Int#
    -> SmallMutableArray# s a
    -> Int#
    -> Int#
    -> State# s
    -> State# s
    forall d a.
    SmallMutableArray# d a
    -> Int#
    -> SmallMutableArray# d a
    -> Int#
    -> Int#
    -> State# d
    -> State# d
    copySmallMutableArray# SmallMutableArray# s a
    arr0 Int#
    0# SmallMutableArray# s a
    arr1 Int#
    0# Int#
    szOld State# s
    s2 of
                State# s
    s3 -> (# State# s
    s3, SmallMutableArray# s a
    arr1 #)
            else (# State# s
    s1, SmallMutableArray# s a
    arr0 #)

    -- | Semantically, @considerAccessible = True@. But it has special meaning
    -- to the pattern-match checker, which will never flag the clause in which
    -- 'considerAccessible' occurs as a guard as redundant or inaccessible.
    -- Example:
    --
    -- > case (x, x) of
    -- >   (True,  True)  -> 1
    -- >   (False, False) -> 2
    -- >   (True,  False) -> 3 -- Warning: redundant
    --
    -- The pattern-match checker will warn here that the third clause is redundant.
    -- It will stop doing so if the clause is adorned with 'considerAccessible':
    --
    -- > case (x, x) of
    -- >   (True,  True)  -> 1
    -- >   (False, False) -> 2
    -- >   (True,  False) | considerAccessible -> 3 -- No warning
    --
    -- Put 'considerAccessible' as the last statement of the guard to avoid get
    -- confusing results from the pattern-match checker, which takes \"consider
    -- accessible\" by word.
    considerAccessible :: Bool
    considerAccessible :: Bool
    considerAccessible = Bool
    True