    {-# LANGUAGE MagicHash #-}
    {-# LANGUAGE NoImplicitPrelude #-}

    {-# OPTIONS_HADDOCK not-home #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  GHC.Ix
    -- Copyright   :  (c) The University of Glasgow, 1994-2000
    -- License     :  see libraries/base/LICENSE
    --
    -- Maintainer  :  cvs-ghc@haskell.org
    -- Stability   :  internal
    -- Portability :  non-portable (GHC extensions)
    --
    -- GHC\'s Ix typeclass implementation.
    --
    -----------------------------------------------------------------------------

    module GHC.Ix (
            Ix(..), indexError
        ) where

    import GHC.Enum
    import GHC.Num
    import GHC.Base
    import GHC.Real( fromIntegral )
    import GHC.Show
    import GHC.Tuple (Solo (..))

    -- | The 'Ix' class is used to map a contiguous subrange of values in
    -- a type onto integers.  It is used primarily for array indexing
    -- (see the array package).
    --
    -- The first argument @(l,u)@ of each of these operations is a pair
    -- specifying the lower and upper bounds of a contiguous subrange of values.
    --
    -- An implementation is entitled to assume the following laws about these
    -- operations:
    --
    -- * @'inRange' (l,u) i == 'elem' i ('range' (l,u))@ @ @
    --
    -- * @'range' (l,u) '!!' 'index' (l,u) i == i@, when @'inRange' (l,u) i@
    --
    -- * @'map' ('index' (l,u)) ('range' (l,u))) == [0..'rangeSize' (l,u)-1]@ @ @
    --
    -- * @'rangeSize' (l,u) == 'length' ('range' (l,u))@ @ @
    --
    class (Ord a) => Ix a where
        {-# MINIMAL range, (index | unsafeIndex), inRange #-}

        -- | The list of values in the subrange defined by a bounding pair.
        range               :: (a,a) -> [a]
        -- | The position of a subscript in the subrange.
        index               :: (a,a) -> a -> Int
        -- | Like 'index', but without checking that the value is in range.
        unsafeIndex         :: (a,a) -> a -> Int
        -- | Returns 'True' the given subscript lies in the range defined
        -- the bounding pair.
        inRange             :: (a,a) -> a -> Bool
        -- | The size of the subrange defined by a bounding pair.
        rangeSize           :: (a,a) -> Int
        -- | like 'rangeSize', but without checking that the upper bound is
        -- in range.
        unsafeRangeSize     :: (a,a) -> Int

            -- Must specify one of index, unsafeIndex

            -- 'index' is typically over-ridden in instances, with essentially
            -- the same code, but using indexError instead of hopelessIndexError
            -- Reason: we have 'Show' at the instances
        {-# INLINE index #-}  -- See Note [Inlining index]
        index (a, a)
    b a
    i | (a, a) -> a -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a, a)
    b a
    i = (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a, a)
    b a
    i
                  | Bool
    otherwise   = Int
    hopelessIndexError

        unsafeIndex (a, a)
    b a
    i = (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    index (a, a)
    b a
    i

        rangeSize b :: (a, a)
    b@(a
    _l,a
    h) | (a, a) -> a -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a, a)
    b a
    h = (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a, a)
    b a
    h Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1
                           | Bool
    otherwise   = Int
    0        -- This case is only here to
                                                    -- check for an empty range
            -- NB: replacing (inRange b h) by (l <= h) fails for
            --     tuples.  E.g.  (1,2) <= (2,1) but the range is empty

        unsafeRangeSize b :: (a, a)
    b@(a
    _l,a
    h) = (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a, a)
    b a
    h Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1

    {-
    Note that the following is NOT right
            rangeSize (l,h) | l <= h    = index b h + 1
                            | otherwise = 0

    Because it might be the case that l<h, but the range
    is nevertheless empty.  Consider
            ((1,2),(2,1))
    Here l<h, but the second index ranges from 2..1 and
    hence is empty

    Note [Inlining index]
    ~~~~~~~~~~~~~~~~~~~~~
    We inline the 'index' operation,

     * Partly because it generates much faster code
       (although bigger); see #1216

     * Partly because it exposes the bounds checks to the simplifier which
       might help a big.

    If you make a per-instance index method, you may consider inlining it.

    Note [Double bounds-checking of index values]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    When you index an array, a!x, there are two possible bounds checks we might make:

      (A) Check that (inRange (bounds a) x) holds.

          (A) is checked in the method for 'index'

      (B) Check that (index (bounds a) x) lies in the range 0..n,
          where n is the size of the underlying array

          (B) is checked in the top-level function (!), in safeIndex.

    Of course it *should* be the case that (A) holds iff (B) holds, but that
    is a property of the particular instances of index, bounds, and inRange,
    so GHC cannot guarantee it.

     * If you do (A) and not (B), then you might get a seg-fault,
       by indexing at some bizarre location.  #1610

     * If you do (B) but not (A), you may get no complaint when you index
       an array out of its semantic bounds.  #2120

    At various times we have had (A) and not (B), or (B) and not (A); both
    led to complaints.  So now we implement *both* checks (#2669).

    For 1-d, 2-d, and 3-d arrays of Int we have specialised instances to avoid this.

    Note [Out-of-bounds error messages]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    The default method for 'index' generates hoplelessIndexError, because
    Ix doesn't have Show as a superclass.  For particular base types we
    can do better, so we override the default method for index.

    Note [indexError]
    ~~~~~~~~~~~~~~~~~
    We abstract the guts of constructing an out-of-bounds error into `indexError`.
    We give it a NOINLINE pragma, because we don't want to duplicate this
    cold-path code.

    We give it a SPECIALISE pragma because we really want it to take
    its arguments unboxed, to avoid reboxing code in the caller, and
    perhaps even some reboxing code in the hot path of a caller.
    See Note [Boxity for bottoming functions] in GHC.Core.Opt.DmdAnal.

    The SPECIALISE pragma means that at least the Int-indexed case
    of indexError /will/ unbox its arguments.

    The [2] phase is because if we don't give an activation we'll get
    the one from the inline pragama (i.e. never) which is a bit silly.
    See Note [Activation pragmas for SPECIALISE] in GHC.HsToCore.Binds.
    -}

    -- indexError: see Note [indexError]
    {-# NOINLINE indexError #-}
    {-# SPECIALISE [2] indexError :: (Int,Int) -> Int -> String -> b #-}

    indexError :: Show a => (a,a) -> a -> String -> b
    indexError :: forall a b. Show a => (a, a) -> a -> String -> b
    indexError (a, a)
    rng a
    i String
    tp
      = String -> b
    forall a. String -> a
    errorWithoutStackTrace (String -> ShowS
    showString String
    "Ix{" ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ShowS
    showString String
    tp ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> ShowS
    showString String
    "}.index: Index " ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
               Bool -> ShowS -> ShowS
    showParen Bool
    True (Int -> a -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    0 a
    i) ShowS -> ShowS -> ShowS
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .
               String -> ShowS
    showString String
    " out of range " ShowS -> ShowS
    forall a b. (a -> b) -> a -> b
    $
               Bool -> ShowS -> ShowS
    showParen Bool
    True (Int -> (a, a) -> ShowS
    forall a. Show a => Int -> a -> ShowS
    showsPrec Int
    0 (a, a)
    rng) String
    "")

    hopelessIndexError :: Int -- Try to use 'indexError' instead!
    hopelessIndexError :: Int
    hopelessIndexError = String -> Int
    forall a. String -> a
    errorWithoutStackTrace String
    "Error in array index"

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance  Ix Char  where
        {-# INLINE range #-}
        range :: (Char, Char) -> String
    range (Char
    m,Char
    n) = [Char
    m..Char
    n]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: (Char, Char) -> Char -> Int
    unsafeIndex (Char
    m,Char
    _n) Char
    i = Char -> Int
    forall a. Enum a => a -> Int
    fromEnum Char
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Char -> Int
    forall a. Enum a => a -> Int
    fromEnum Char
    m

        {-# INLINE index #-}  -- See Note [Out-of-bounds error messages]
                              -- and Note [Inlining index]
        index :: (Char, Char) -> Char -> Int
    index (Char, Char)
    b Char
    i | (Char, Char) -> Char -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (Char, Char)
    b Char
    i =  (Char, Char) -> Char -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (Char, Char)
    b Char
    i
                  | Bool
    otherwise   =  (Char, Char) -> Char -> String -> Int
    forall a b. Show a => (a, a) -> a -> String -> b
    indexError (Char, Char)
    b Char
    i String
    "Char"

        inRange :: (Char, Char) -> Char -> Bool
    inRange (Char
    m,Char
    n) Char
    i     =  Char
    m Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    i Bool -> Bool -> Bool
    && Char
    i Char -> Char -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Char
    n

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance  Ix Int  where
        {-# INLINE range #-}
            -- The INLINE stops the build in the RHS from getting inlined,
            -- so that callers can fuse with the result of range
        range :: (Int, Int) -> [Int]
    range (Int
    m,Int
    n) = [Int
    m..Int
    n]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: (Int, Int) -> Int -> Int
    unsafeIndex (Int
    m,Int
    _n) Int
    i = Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    m

        {-# INLINE index #-}  -- See Note [Out-of-bounds error messages]
                              -- and Note [Inlining index]
        index :: (Int, Int) -> Int -> Int
    index (Int, Int)
    b Int
    i | (Int, Int) -> Int -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (Int, Int)
    b Int
    i =  (Int, Int) -> Int -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (Int, Int)
    b Int
    i
                  | Bool
    otherwise   =  (Int, Int) -> Int -> String -> Int
    forall a b. Show a => (a, a) -> a -> String -> b
    indexError (Int, Int)
    b Int
    i String
    "Int"

        {-# INLINE inRange #-}
        inRange :: (Int, Int) -> Int -> Bool
    inRange (I# Int#
    m,I# Int#
    n) (I# Int#
    i) =  Int# -> Bool
    isTrue# (Int#
    m Int# -> Int# -> Int#
    <=# Int#
    i) Bool -> Bool -> Bool
    && Int# -> Bool
    isTrue# (Int#
    i Int# -> Int# -> Int#
    <=# Int#
    n)

    -- | @since 4.6.0.0
    instance Ix Word where
        range :: (Word, Word) -> [Word]
    range (Word
    m,Word
    n)         = [Word
    m..Word
    n]
        unsafeIndex :: (Word, Word) -> Word -> Int
    unsafeIndex (Word
    m,Word
    _) Word
    i = Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Word
    i Word -> Word -> Word
    forall a. Num a => a -> a -> a
    - Word
    m)
        inRange :: (Word, Word) -> Word -> Bool
    inRange (Word
    m,Word
    n) Word
    i     = Word
    m Word -> Word -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word
    i Bool -> Bool -> Bool
    && Word
    i Word -> Word -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Word
    n

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance  Ix Integer  where
        {-# INLINE range #-}
        range :: (Integer, Integer) -> [Integer]
    range (Integer
    m,Integer
    n) = [Integer
    m..Integer
    n]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: (Integer, Integer) -> Integer -> Int
    unsafeIndex (Integer
    m,Integer
    _n) Integer
    i   = Integer -> Int
    forall a. Num a => Integer -> a
    fromInteger (Integer
    i Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    - Integer
    m)

        {-# INLINE index #-}  -- See Note [Out-of-bounds error messages]
                              -- and Note [Inlining index]
        index :: (Integer, Integer) -> Integer -> Int
    index (Integer, Integer)
    b Integer
    i | (Integer, Integer) -> Integer -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (Integer, Integer)
    b Integer
    i =  (Integer, Integer) -> Integer -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (Integer, Integer)
    b Integer
    i
                  | Bool
    otherwise   =  (Integer, Integer) -> Integer -> String -> Int
    forall a b. Show a => (a, a) -> a -> String -> b
    indexError (Integer, Integer)
    b Integer
    i String
    "Integer"

        inRange :: (Integer, Integer) -> Integer -> Bool
    inRange (Integer
    m,Integer
    n) Integer
    i     =  Integer
    m Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Integer
    i Bool -> Bool -> Bool
    && Integer
    i Integer -> Integer -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Integer
    n

    ----------------------------------------------------------------------
    -- | @since 4.8.0.0
    instance Ix Natural where
        range :: (Natural, Natural) -> [Natural]
    range (Natural
    m,Natural
    n) = [Natural
    m..Natural
    n]
        inRange :: (Natural, Natural) -> Natural -> Bool
    inRange (Natural
    m,Natural
    n) Natural
    i = Natural
    m Natural -> Natural -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Natural
    i Bool -> Bool -> Bool
    && Natural
    i Natural -> Natural -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Natural
    n
        unsafeIndex :: (Natural, Natural) -> Natural -> Int
    unsafeIndex (Natural
    m,Natural
    _) Natural
    i = Natural -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Natural
    iNatural -> Natural -> Natural
    forall a. Num a => a -> a -> a
    -Natural
    m)
        index :: (Natural, Natural) -> Natural -> Int
    index (Natural, Natural)
    b Natural
    i | (Natural, Natural) -> Natural -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (Natural, Natural)
    b Natural
    i = (Natural, Natural) -> Natural -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (Natural, Natural)
    b Natural
    i
                  | Bool
    otherwise   = (Natural, Natural) -> Natural -> String -> Int
    forall a b. Show a => (a, a) -> a -> String -> b
    indexError (Natural, Natural)
    b Natural
    i String
    "Natural"

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance Ix Bool where -- as derived
        {-# INLINE range #-}
        range :: (Bool, Bool) -> [Bool]
    range (Bool
    m,Bool
    n) = [Bool
    m..Bool
    n]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: (Bool, Bool) -> Bool -> Int
    unsafeIndex (Bool
    l,Bool
    _) Bool
    i = Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum Bool
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum Bool
    l

        {-# INLINE index #-}  -- See Note [Out-of-bounds error messages]
                              -- and Note [Inlining index]
        index :: (Bool, Bool) -> Bool -> Int
    index (Bool, Bool)
    b Bool
    i | (Bool, Bool) -> Bool -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (Bool, Bool)
    b Bool
    i =  (Bool, Bool) -> Bool -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (Bool, Bool)
    b Bool
    i
                  | Bool
    otherwise   =  (Bool, Bool) -> Bool -> String -> Int
    forall a b. Show a => (a, a) -> a -> String -> b
    indexError (Bool, Bool)
    b Bool
    i String
    "Bool"

        inRange :: (Bool, Bool) -> Bool -> Bool
    inRange (Bool
    l,Bool
    u) Bool
    i = Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum Bool
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum Bool
    l Bool -> Bool -> Bool
    && Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum Bool
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Bool -> Int
    forall a. Enum a => a -> Int
    fromEnum Bool
    u

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance Ix Ordering where -- as derived
        {-# INLINE range #-}
        range :: (Ordering, Ordering) -> [Ordering]
    range (Ordering
    m,Ordering
    n) = [Ordering
    m..Ordering
    n]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: (Ordering, Ordering) -> Ordering -> Int
    unsafeIndex (Ordering
    l,Ordering
    _) Ordering
    i = Ordering -> Int
    forall a. Enum a => a -> Int
    fromEnum Ordering
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Ordering -> Int
    forall a. Enum a => a -> Int
    fromEnum Ordering
    l

        {-# INLINE index #-}  -- See Note [Out-of-bounds error messages]
                              -- and Note [Inlining index]
        index :: (Ordering, Ordering) -> Ordering -> Int
    index (Ordering, Ordering)
    b Ordering
    i | (Ordering, Ordering) -> Ordering -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (Ordering, Ordering)
    b Ordering
    i =  (Ordering, Ordering) -> Ordering -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (Ordering, Ordering)
    b Ordering
    i
                  | Bool
    otherwise   =  (Ordering, Ordering) -> Ordering -> String -> Int
    forall a b. Show a => (a, a) -> a -> String -> b
    indexError (Ordering, Ordering)
    b Ordering
    i String
    "Ordering"

        inRange :: (Ordering, Ordering) -> Ordering -> Bool
    inRange (Ordering
    l,Ordering
    u) Ordering
    i = Ordering -> Int
    forall a. Enum a => a -> Int
    fromEnum Ordering
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Ordering -> Int
    forall a. Enum a => a -> Int
    fromEnum Ordering
    l Bool -> Bool -> Bool
    && Ordering -> Int
    forall a. Enum a => a -> Int
    fromEnum Ordering
    i Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Ordering -> Int
    forall a. Enum a => a -> Int
    fromEnum Ordering
    u

    ----------------------------------------------------------------------
    -- | @since 4.8.0.0
    instance Ix Void where
        range :: (Void, Void) -> [Void]
    range (Void, Void)
    _     = []
        index :: (Void, Void) -> Void -> Int
    index (Void, Void)
    _     = Void -> Int
    forall a. Void -> a
    absurd
        inRange :: (Void, Void) -> Void -> Bool
    inRange (Void, Void)
    _   = Void -> Bool
    forall a. Void -> a
    absurd
        rangeSize :: (Void, Void) -> Int
    rangeSize (Void, Void)
    _ = Int
    0

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance Ix () where
        {-# INLINE range #-}
        range :: ((), ()) -> [()]
    range   ((), ())    = [()]
        {-# INLINE unsafeIndex #-}
        unsafeIndex :: ((), ()) -> () -> Int
    unsafeIndex   ((), ()) () = Int
    0
        {-# INLINE inRange #-}
        inRange :: ((), ()) -> () -> Bool
    inRange ((), ()) () = Bool
    True

        {-# INLINE index #-}  -- See Note [Inlining index]
        index :: ((), ()) -> () -> Int
    index ((), ())
    b ()
    i = ((), ()) -> () -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex ((), ())
    b ()
    i

    instance Ix a => Ix (Solo a) where -- as derived
        {-# SPECIALISE instance Ix (Solo Int) #-}

        {-# INLINE range #-}
        range :: (Solo a, Solo a) -> [Solo a]
    range (MkSolo a
    l, MkSolo a
    u) =
          [ a -> Solo a
    forall a. a -> Solo a
    MkSolo a
    i | a
    i <- (a, a) -> [a]
    forall a. Ix a => (a, a) -> [a]
    range (a
    l,a
    u) ]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: (Solo a, Solo a) -> Solo a -> Int
    unsafeIndex (MkSolo a
    l, MkSolo a
    u) (MkSolo a
    i) =
          (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a
    l,a
    u) a
    i

        {-# INLINE inRange #-}
        inRange :: (Solo a, Solo a) -> Solo a -> Bool
    inRange (MkSolo a
    l, MkSolo a
    u) (MkSolo a
    i) =
          (a, a) -> a -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a
    l, a
    u) a
    i

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance (Ix a, Ix b) => Ix (a, b) where -- as derived
        {-# SPECIALISE instance Ix (Int,Int) #-}

        {-# INLINE range #-}
        range :: ((a, b), (a, b)) -> [(a, b)]
    range ((a
    l1,b
    l2),(a
    u1,b
    u2)) =
          [ (a
    i1,b
    i2) | a
    i1 <- (a, a) -> [a]
    forall a. Ix a => (a, a) -> [a]
    range (a
    l1,a
    u1), b
    i2 <- (b, b) -> [b]
    forall a. Ix a => (a, a) -> [a]
    range (b
    l2,b
    u2) ]

        {-# INLINE unsafeIndex #-}
        unsafeIndex :: ((a, b), (a, b)) -> (a, b) -> Int
    unsafeIndex ((a
    l1,b
    l2),(a
    u1,b
    u2)) (a
    i1,b
    i2) =
          (a, a) -> a -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a
    l1,a
    u1) a
    i1 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (b, b) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (b
    l2,b
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (b, b) -> b -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (b
    l2,b
    u2) b
    i2

        {-# INLINE inRange #-}
        inRange :: ((a, b), (a, b)) -> (a, b) -> Bool
    inRange ((a
    l1,b
    l2),(a
    u1,b
    u2)) (a
    i1,b
    i2) =
          (a, a) -> a -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a
    l1,a
    u1) a
    i1 Bool -> Bool -> Bool
    && (b, b) -> b -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (b
    l2,b
    u2) b
    i2

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance  (Ix a1, Ix a2, Ix a3) => Ix (a1,a2,a3)  where
        {-# SPECIALISE instance Ix (Int,Int,Int) #-}

        range :: ((a1, a2, a3), (a1, a2, a3)) -> [(a1, a2, a3)]
    range ((a1
    l1,a2
    l2,a3
    l3),(a1
    u1,a2
    u2,a3
    u3)) =
            [(a1
    i1,a2
    i2,a3
    i3) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                          a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                          a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3)]

        unsafeIndex :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3),(a1
    u1,a2
    u2,a3
    u3)) (a1
    i1,a2
    i2,a3
    i3) =
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))

        inRange :: ((a1, a2, a3), (a1, a2, a3)) -> (a1, a2, a3) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3),(a1
    u1,a2
    u2,a3
    u3)) (a1
    i1,a2
    i2,a3
    i3) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance  (Ix a1, Ix a2, Ix a3, Ix a4) => Ix (a1,a2,a3,a4)  where
        range :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> [(a1, a2, a3, a4)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4),(a1
    u1,a2
    u2,a3
    u3,a4
    u4)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                           a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                           a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                           a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4)]

        unsafeIndex :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4),(a1
    u1,a2
    u2,a3
    u3,a4
    u4)) (a1
    i1,a2
    i2,a3
    i3,a4
    i4) =
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1)))

        inRange :: ((a1, a2, a3, a4), (a1, a2, a3, a4)) -> (a1, a2, a3, a4) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4),(a1
    u1,a2
    u2,a3
    u3,a4
    u4)) (a1
    i1,a2
    i2,a3
    i3,a4
    i4) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 2.01
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1,a2,a3,a4,a5)  where
        range :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5))
    -> [(a1, a2, a3, a4, a5)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                              a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                              a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                              a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                              a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5)]

        unsafeIndex :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5))
    -> (a1, a2, a3, a4, a5) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5)) (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5) =
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))))

        inRange :: ((a1, a2, a3, a4, a5), (a1, a2, a3, a4, a5))
    -> (a1, a2, a3, a4, a5) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5)) (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6) =>
          Ix (a1,a2,a3,a4,a5,a6)  where
        range :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6))
    -> [(a1, a2, a3, a4, a5, a6)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                 a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                 a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                 a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                 a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                 a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6))
    -> (a1, a2, a3, a4, a5, a6) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6)) (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6) =
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1)))))

        inRange :: ((a1, a2, a3, a4, a5, a6), (a1, a2, a3, a4, a5, a6))
    -> (a1, a2, a3, a4, a5, a6) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6)) (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7) =>
          Ix (a1,a2,a3,a4,a5,a6,a7)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7))
    -> [(a1, a2, a3, a4, a5, a6, a7)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                    a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                    a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                    a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                    a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                    a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                    a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7))
    -> (a1, a2, a3, a4, a5, a6, a7) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7) =
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7), (a1, a2, a3, a4, a5, a6, a7))
    -> (a1, a2, a3, a4, a5, a6, a7) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8),
     (a1, a2, a3, a4, a5, a6, a7, a8))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                       a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                       a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                       a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                       a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                       a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                       a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                       a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8),
     (a1, a2, a3, a4, a5, a6, a7, a8))
    -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8) =
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1)))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8),
     (a1, a2, a3, a4, a5, a6, a7, a8))
    -> (a1, a2, a3, a4, a5, a6, a7, a8) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                          a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                          a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                          a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                          a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                          a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                          a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                          a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                          a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9) =
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
               Ix aA) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                             a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                             a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                             a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                             a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                             a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                             a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                             a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                             a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9),
                                             aA
    iA <- (aA, aA) -> [aA]
    forall a. Ix a => (a, a) -> [a]
    range (aA
    lA,aA
    uA)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA),
                     (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA) =
          (aA, aA) -> aA -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aA
    lA,aA
    uA) aA
    iA Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aA, aA) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aA
    lA,aA
    uA) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1)))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA),(a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9 Bool -> Bool -> Bool
    && (aA, aA) -> aA -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aA
    lA,aA
    uA) aA
    iA

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
               Ix aA, Ix aB) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB),
               (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                                a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                                a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                                a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                                a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                                a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                                a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                                a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                                a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9),
                                                aA
    iA <- (aA, aA) -> [aA]
    forall a. Ix a => (a, a) -> [a]
    range (aA
    lA,aA
    uA),
                                                aB
    iB <- (aB, aB) -> [aB]
    forall a. Ix a => (a, a) -> [a]
    range (aB
    lB,aB
    uB)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB),
                     (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB) =
          (aB, aB) -> aB -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aB
    lB,aB
    uB) aB
    iB Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aB, aB) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aB
    lB,aB
    uB) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aA, aA) -> aA -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aA
    lA,aA
    uA) aA
    iA Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aA, aA) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aA
    lA,aA
    uA) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB),
                 (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9 Bool -> Bool -> Bool
    && (aA, aA) -> aA -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aA
    lA,aA
    uA) aA
    iA Bool -> Bool -> Bool
    &&
          (aB, aB) -> aB -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aB
    lB,aB
    uB) aB
    iB

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
               Ix aA, Ix aB, Ix aC) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC),
               (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                                   a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                                   a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                                   a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                                   a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                                   a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                                   a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                                   a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                                   a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9),
                                                   aA
    iA <- (aA, aA) -> [aA]
    forall a. Ix a => (a, a) -> [a]
    range (aA
    lA,aA
    uA),
                                                   aB
    iB <- (aB, aB) -> [aB]
    forall a. Ix a => (a, a) -> [a]
    range (aB
    lB,aB
    uB),
                                                   aC
    iC <- (aC, aC) -> [aC]
    forall a. Ix a => (a, a) -> [a]
    range (aC
    lC,aC
    uC)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC),
                     (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC) =
          (aC, aC) -> aC -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aC
    lC,aC
    uC) aC
    iC Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aC, aC) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aC
    lC,aC
    uC) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aB, aB) -> aB -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aB
    lB,aB
    uB) aB
    iB Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aB, aB) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aB
    lB,aB
    uB) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aA, aA) -> aA -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aA
    lA,aA
    uA) aA
    iA Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aA, aA) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aA
    lA,aA
    uA) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1)))))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC),
                 (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9 Bool -> Bool -> Bool
    && (aA, aA) -> aA -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aA
    lA,aA
    uA) aA
    iA Bool -> Bool -> Bool
    &&
          (aB, aB) -> aB -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aB
    lB,aB
    uB) aB
    iB Bool -> Bool -> Bool
    && (aC, aC) -> aC -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aC
    lC,aC
    uC) aC
    iC

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
               Ix aA, Ix aB, Ix aC, Ix aD) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD),
               (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                                      a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                                      a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                                      a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                                      a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                                      a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                                      a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                                      a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                                      a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9),
                                                      aA
    iA <- (aA, aA) -> [aA]
    forall a. Ix a => (a, a) -> [a]
    range (aA
    lA,aA
    uA),
                                                      aB
    iB <- (aB, aB) -> [aB]
    forall a. Ix a => (a, a) -> [a]
    range (aB
    lB,aB
    uB),
                                                      aC
    iC <- (aC, aC) -> [aC]
    forall a. Ix a => (a, a) -> [a]
    range (aC
    lC,aC
    uC),
                                                      aD
    iD <- (aD, aD) -> [aD]
    forall a. Ix a => (a, a) -> [a]
    range (aD
    lD,aD
    uD)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD),
                     (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD) =
          (aD, aD) -> aD -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aD
    lD,aD
    uD) aD
    iD Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aD, aD) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aD
    lD,aD
    uD) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aC, aC) -> aC -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aC
    lC,aC
    uC) aC
    iC Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aC, aC) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aC
    lC,aC
    uC) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aB, aB) -> aB -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aB
    lB,aB
    uB) aB
    iB Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aB, aB) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aB
    lB,aB
    uB) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aA, aA) -> aA -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aA
    lA,aA
    uA) aA
    iA Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aA, aA) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aA
    lA,aA
    uA) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))))))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD),
                 (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9 Bool -> Bool -> Bool
    && (aA, aA) -> aA -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aA
    lA,aA
    uA) aA
    iA Bool -> Bool -> Bool
    &&
          (aB, aB) -> aB -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aB
    lB,aB
    uB) aB
    iB Bool -> Bool -> Bool
    && (aC, aC) -> aC -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aC
    lC,aC
    uC) aC
    iC Bool -> Bool -> Bool
    &&
          (aD, aD) -> aD -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aD
    lD,aD
    uD) aD
    iD

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
               Ix aA, Ix aB, Ix aC, Ix aD, Ix aE) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD,aE
    lE),
               (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD,aE
    uE)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD,aE
    iE) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                                         a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                                         a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                                         a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                                         a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                                         a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                                         a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                                         a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                                         a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9),
                                                         aA
    iA <- (aA, aA) -> [aA]
    forall a. Ix a => (a, a) -> [a]
    range (aA
    lA,aA
    uA),
                                                         aB
    iB <- (aB, aB) -> [aB]
    forall a. Ix a => (a, a) -> [a]
    range (aB
    lB,aB
    uB),
                                                         aC
    iC <- (aC, aC) -> [aC]
    forall a. Ix a => (a, a) -> [a]
    range (aC
    lC,aC
    uC),
                                                         aD
    iD <- (aD, aD) -> [aD]
    forall a. Ix a => (a, a) -> [a]
    range (aD
    lD,aD
    uD),
                                                         aE
    iE <- (aE, aE) -> [aE]
    forall a. Ix a => (a, a) -> [a]
    range (aE
    lE,aE
    uE)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD,aE
    lE),
                     (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD,aE
    uE))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD,aE
    iE) =
          (aE, aE) -> aE -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aE
    lE,aE
    uE) aE
    iE Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aE, aE) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aE
    lE,aE
    uE) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aD, aD) -> aD -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aD
    lD,aD
    uD) aD
    iD Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aD, aD) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aD
    lD,aD
    uD) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aC, aC) -> aC -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aC
    lC,aC
    uC) aC
    iC Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aC, aC) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aC
    lC,aC
    uC) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aB, aB) -> aB -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aB
    lB,aB
    uB) aB
    iB Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aB, aB) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aB
    lB,aB
    uB) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aA, aA) -> aA -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aA
    lA,aA
    uA) aA
    iA Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aA, aA) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aA
    lA,aA
    uA) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1)))))))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE) -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD,aE
    lE),
                 (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD,aE
    uE))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD,aE
    iE) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9 Bool -> Bool -> Bool
    && (aA, aA) -> aA -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aA
    lA,aA
    uA) aA
    iA Bool -> Bool -> Bool
    &&
          (aB, aB) -> aB -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aB
    lB,aB
    uB) aB
    iB Bool -> Bool -> Bool
    && (aC, aC) -> aC -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aC
    lC,aC
    uC) aC
    iC Bool -> Bool -> Bool
    &&
          (aD, aD) -> aD -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aD
    lD,aD
    uD) aD
    iD Bool -> Bool -> Bool
    && (aE, aE) -> aE -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aE
    lE,aE
    uE) aE
    iE

        -- Default method for index

    ----------------------------------------------------------------------
    -- | @since 4.15.0.0
    instance  (Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9,
               Ix aA, Ix aB, Ix aC, Ix aD, Ix aE, Ix aF) =>
          Ix (a1,a2,a3,a4,a5,a6,a7,a8,a9,aA,aB,aC,aD,aE,aF)  where
        range :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF))
    -> [(a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)]
    range ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD,aE
    lE,aF
    lF),
               (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD,aE
    uE,aF
    uF)) =
          [(a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD,aE
    iE,aF
    iF) | a1
    i1 <- (a1, a1) -> [a1]
    forall a. Ix a => (a, a) -> [a]
    range (a1
    l1,a1
    u1),
                                                            a2
    i2 <- (a2, a2) -> [a2]
    forall a. Ix a => (a, a) -> [a]
    range (a2
    l2,a2
    u2),
                                                            a3
    i3 <- (a3, a3) -> [a3]
    forall a. Ix a => (a, a) -> [a]
    range (a3
    l3,a3
    u3),
                                                            a4
    i4 <- (a4, a4) -> [a4]
    forall a. Ix a => (a, a) -> [a]
    range (a4
    l4,a4
    u4),
                                                            a5
    i5 <- (a5, a5) -> [a5]
    forall a. Ix a => (a, a) -> [a]
    range (a5
    l5,a5
    u5),
                                                            a6
    i6 <- (a6, a6) -> [a6]
    forall a. Ix a => (a, a) -> [a]
    range (a6
    l6,a6
    u6),
                                                            a7
    i7 <- (a7, a7) -> [a7]
    forall a. Ix a => (a, a) -> [a]
    range (a7
    l7,a7
    u7),
                                                            a8
    i8 <- (a8, a8) -> [a8]
    forall a. Ix a => (a, a) -> [a]
    range (a8
    l8,a8
    u8),
                                                            a9
    i9 <- (a9, a9) -> [a9]
    forall a. Ix a => (a, a) -> [a]
    range (a9
    l9,a9
    u9),
                                                            aA
    iA <- (aA, aA) -> [aA]
    forall a. Ix a => (a, a) -> [a]
    range (aA
    lA,aA
    uA),
                                                            aB
    iB <- (aB, aB) -> [aB]
    forall a. Ix a => (a, a) -> [a]
    range (aB
    lB,aB
    uB),
                                                            aC
    iC <- (aC, aC) -> [aC]
    forall a. Ix a => (a, a) -> [a]
    range (aC
    lC,aC
    uC),
                                                            aD
    iD <- (aD, aD) -> [aD]
    forall a. Ix a => (a, a) -> [a]
    range (aD
    lD,aD
    uD),
                                                            aE
    iE <- (aE, aE) -> [aE]
    forall a. Ix a => (a, a) -> [a]
    range (aE
    lE,aE
    uE),
                                                            aF
    iF <- (aF, aF) -> [aF]
    forall a. Ix a => (a, a) -> [a]
    range (aF
    lF,aF
    uF)]

        unsafeIndex :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)
    -> Int
    unsafeIndex ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD,aE
    lE,aF
    lF),
                     (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD,aE
    uE,aF
    uF))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD,aE
    iE,aF
    iF) =
          (aF, aF) -> aF -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aF
    lF,aF
    uF) aF
    iF Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aF, aF) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aF
    lF,aF
    uF) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aE, aE) -> aE -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aE
    lE,aE
    uE) aE
    iE Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aE, aE) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aE
    lE,aE
    uE) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aD, aD) -> aD -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aD
    lD,aD
    uD) aD
    iD Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aD, aD) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aD
    lD,aD
    uD) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aC, aC) -> aC -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aC
    lC,aC
    uC) aC
    iC Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aC, aC) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aC
    lC,aC
    uC) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aB, aB) -> aB -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aB
    lB,aB
    uB) aB
    iB Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aB, aB) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aB
    lB,aB
    uB) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (aA, aA) -> aA -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (aA
    lA,aA
    uA) aA
    iA Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (aA, aA) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (aA
    lA,aA
    uA) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a9, a9) -> a9 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a9
    l9,a9
    u9) a9
    i9 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a9, a9) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a9
    l9,a9
    u9) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a8, a8) -> a8 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a8
    l8,a8
    u8) a8
    i8 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a8, a8) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a8
    l8,a8
    u8) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a7, a7) -> a7 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a7
    l7,a7
    u7) a7
    i7 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a7, a7) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a7
    l7,a7
    u7) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a6, a6) -> a6 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a6
    l6,a6
    u6) a6
    i6 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a6, a6) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a6
    l6,a6
    u6) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a5, a5) -> a5 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a5
    l5,a5
    u5) a5
    i5 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a5, a5) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a5
    l5,a5
    u5) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a4, a4) -> a4 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a4
    l4,a4
    u4) a4
    i4 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a4, a4) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a4
    l4,a4
    u4) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a3, a3) -> a3 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a3
    l3,a3
    u3) a3
    i3 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a3, a3) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a3
    l3,a3
    u3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a2, a2) -> a2 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a2
    l2,a2
    u2) a2
    i2 Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + (a2, a2) -> Int
    forall a. Ix a => (a, a) -> Int
    unsafeRangeSize (a2
    l2,a2
    u2) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    * (
          (a1, a1) -> a1 -> Int
    forall a. Ix a => (a, a) -> a -> Int
    unsafeIndex (a1
    l1,a1
    u1) a1
    i1))))))))))))))

        inRange :: ((a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF),
     (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF))
    -> (a1, a2, a3, a4, a5, a6, a7, a8, a9, aA, aB, aC, aD, aE, aF)
    -> Bool
    inRange ((a1
    l1,a2
    l2,a3
    l3,a4
    l4,a5
    l5,a6
    l6,a7
    l7,a8
    l8,a9
    l9,aA
    lA,aB
    lB,aC
    lC,aD
    lD,aE
    lE,aF
    lF),
                 (a1
    u1,a2
    u2,a3
    u3,a4
    u4,a5
    u5,a6
    u6,a7
    u7,a8
    u8,a9
    u9,aA
    uA,aB
    uB,aC
    uC,aD
    uD,aE
    uE,aF
    uF))
            (a1
    i1,a2
    i2,a3
    i3,a4
    i4,a5
    i5,a6
    i6,a7
    i7,a8
    i8,a9
    i9,aA
    iA,aB
    iB,aC
    iC,aD
    iD,aE
    iE,aF
    iF) =
          (a1, a1) -> a1 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a1
    l1,a1
    u1) a1
    i1 Bool -> Bool -> Bool
    && (a2, a2) -> a2 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a2
    l2,a2
    u2) a2
    i2 Bool -> Bool -> Bool
    &&
          (a3, a3) -> a3 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a3
    l3,a3
    u3) a3
    i3 Bool -> Bool -> Bool
    && (a4, a4) -> a4 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a4
    l4,a4
    u4) a4
    i4 Bool -> Bool -> Bool
    &&
          (a5, a5) -> a5 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a5
    l5,a5
    u5) a5
    i5 Bool -> Bool -> Bool
    && (a6, a6) -> a6 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a6
    l6,a6
    u6) a6
    i6 Bool -> Bool -> Bool
    &&
          (a7, a7) -> a7 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a7
    l7,a7
    u7) a7
    i7 Bool -> Bool -> Bool
    && (a8, a8) -> a8 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a8
    l8,a8
    u8) a8
    i8 Bool -> Bool -> Bool
    &&
          (a9, a9) -> a9 -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (a9
    l9,a9
    u9) a9
    i9 Bool -> Bool -> Bool
    && (aA, aA) -> aA -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aA
    lA,aA
    uA) aA
    iA Bool -> Bool -> Bool
    &&
          (aB, aB) -> aB -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aB
    lB,aB
    uB) aB
    iB Bool -> Bool -> Bool
    && (aC, aC) -> aC -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aC
    lC,aC
    uC) aC
    iC Bool -> Bool -> Bool
    &&
          (aD, aD) -> aD -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aD
    lD,aD
    uD) aD
    iD Bool -> Bool -> Bool
    && (aE, aE) -> aE -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aE
    lE,aE
    uE) aE
    iE Bool -> Bool -> Bool
    &&
          (aF, aF) -> aF -> Bool
    forall a. Ix a => (a, a) -> a -> Bool
    inRange (aF
    lF,aF
    uF) aF
    iF

        -- Default method for index