    {-# LANGUAGE DataKinds #-}
    -- |
    -- Module: Data.Tuple.Optics
    -- Description: 'Lens'es for tuple types.
    --
    -- This module defines 'Lens'es for the fields of tuple types.  These are
    -- overloaded using the 'Field1' to 'Field9' typeclasses, so that '_1' can be
    -- used as a 'Lens' for the first field of a tuple with any number of fields (up
    -- to the maximum supported tuple size, which is currently 9).  For example:
    --
    -- >>> view _1 ('a','b','c')
    -- 'a'
    --
    -- >>> set _3 True ('a','b','c')
    -- ('a','b',True)
    --
    -- If a datatype has a 'Generic' instance, the corresponding @FieldN@ instances
    -- can be defined using their default methods:
    --
    -- >>> :set -XDeriveGeneric
    -- >>> import GHC.Generics (Generic)
    -- >>> data T a b = MkT a Int b deriving (Generic, Show)
    -- >>> instance Field1 (T a c) (T b c) a b
    -- >>> instance Field2 (T a b) (T a b) Int Int
    -- >>> instance Field3 (T c a) (T c b) a b
    --
    -- >>> set _3 'x' (MkT False 1 ())
    -- MkT False 1 'x'
    --
    -- For a generalization of this pattern see 'GPosition'.
    --
    module Data.Tuple.Optics
      (
      -- * Tuples
        Field1(..)
      , Field2(..)
      , Field3(..)
      , Field4(..)
      , Field5(..)
      , Field6(..)
      , Field7(..)
      , Field8(..)
      , Field9(..)
      -- * Strict variations
      , _1', _2', _3', _4', _5', _6', _7', _8', _9'
      ) where

    import Data.Functor.Identity
    import Data.Functor.Product
    import GHC.Generics ((:*:)(..))

    import Optics.Generic
    import Optics.Lens
    import Optics.Optic

    -- | Provides access to 1st field of a tuple.
    class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 1st field of a tuple (and possibly change its type).
      --
      -- >>> (1,2) ^. _1
      -- 1
      --
      -- >>> (1,2) & _1 .~ "hello"
      -- ("hello",2)
      --
      -- >>> traverseOf _1 putStrLn ("hello","world")
      -- hello
      -- ((),"world")
      --
      -- This can also be used on larger tuples as well:
      --
      -- >>> (1,2,3,4,5) & _1 %~ (+41)
      -- (42,2,3,4,5)
      _1 :: Lens s t a b
      default _1 :: GPosition 1 s t a b => Lens s t a b
      _1 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @1
      {-# INLINE[1] _1 #-}

    instance Field1 (Identity a) (Identity b) a b where
      _1 :: Lens (Identity a) (Identity b) a b
    _1 = LensVL (Identity a) (Identity b) a b
    -> Lens (Identity a) (Identity b) a b
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (Identity a) (Identity b) a b
     -> Lens (Identity a) (Identity b) a b)
    -> LensVL (Identity a) (Identity b) a b
    -> Lens (Identity a) (Identity b) a b
    forall a b. (a -> b) -> a -> b
    $ \a -> f b
    f (Identity a
    a) -> b -> Identity b
    forall a. a -> Identity a
    Identity (b -> Identity b) -> f b -> f (Identity b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f b
    f a
    a
      {-# INLINE[1] _1 #-}

    instance Field1 (Product f g a) (Product f' g a) (f a) (f' a) where
      _1 :: Lens (Product f g a) (Product f' g a) (f a) (f' a)
    _1 = LensVL (Product f g a) (Product f' g a) (f a) (f' a)
    -> Lens (Product f g a) (Product f' g a) (f a) (f' a)
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (Product f g a) (Product f' g a) (f a) (f' a)
     -> Lens (Product f g a) (Product f' g a) (f a) (f' a))
    -> LensVL (Product f g a) (Product f' g a) (f a) (f' a)
    -> Lens (Product f g a) (Product f' g a) (f a) (f' a)
    forall a b. (a -> b) -> a -> b
    $ \f a -> f (f' a)
    f ~(Pair f a
    a g a
    b) -> (f' a -> g a -> Product f' g a) -> g a -> f' a -> Product f' g a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip f' a -> g a -> Product f' g a
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair g a
    b (f' a -> Product f' g a) -> f (f' a) -> f (Product f' g a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f a -> f (f' a)
    f f a
    a
      {-# INLINE[1] _1 #-}

    instance Field1 ((f :*: g) p) ((f' :*: g) p) (f p) (f' p) where
      _1 :: Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
    _1 = LensVL ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
    -> Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
     -> Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p))
    -> LensVL ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
    -> Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
    forall a b. (a -> b) -> a -> b
    $ \f p -> f (f' p)
    f ~(f p
    l :*: g p
    r) -> (f' p -> g p -> (:*:) f' g p
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: g p
    r) (f' p -> (:*:) f' g p) -> f (f' p) -> f ((:*:) f' g p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f p -> f (f' p)
    f f p
    l
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b) (a',b) a a' where
      _1 :: Lens (a, b) (a', b) a a'
    _1 = LensVL (a, b) (a', b) a a' -> Lens (a, b) (a', b) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b) (a', b) a a' -> Lens (a, b) (a', b) a a')
    -> LensVL (a, b) (a', b) a a' -> Lens (a, b) (a', b) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b) -> a -> f a'
    k a
    a f a' -> (a' -> (a', b)) -> f (a', b)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c) (a',b,c) a a' where
      _1 :: Lens (a, b, c) (a', b, c) a a'
    _1 = LensVL (a, b, c) (a', b, c) a a' -> Lens (a, b, c) (a', b, c) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c) (a', b, c) a a'
     -> Lens (a, b, c) (a', b, c) a a')
    -> LensVL (a, b, c) (a', b, c) a a'
    -> Lens (a, b, c) (a', b, c) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c) -> a -> f a'
    k a
    a f a' -> (a' -> (a', b, c)) -> f (a', b, c)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c,d) (a',b,c,d) a a' where
      _1 :: Lens (a, b, c, d) (a', b, c, d) a a'
    _1 = LensVL (a, b, c, d) (a', b, c, d) a a'
    -> Lens (a, b, c, d) (a', b, c, d) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d) (a', b, c, d) a a'
     -> Lens (a, b, c, d) (a', b, c, d) a a')
    -> LensVL (a, b, c, d) (a', b, c, d) a a'
    -> Lens (a, b, c, d) (a', b, c, d) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c,d
    d) -> a -> f a'
    k a
    a f a' -> (a' -> (a', b, c, d)) -> f (a', b, c, d)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c,d
    d)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c,d,e) (a',b,c,d,e) a a' where
      _1 :: Lens (a, b, c, d, e) (a', b, c, d, e) a a'
    _1 = LensVL (a, b, c, d, e) (a', b, c, d, e) a a'
    -> Lens (a, b, c, d, e) (a', b, c, d, e) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e) (a', b, c, d, e) a a'
     -> Lens (a, b, c, d, e) (a', b, c, d, e) a a')
    -> LensVL (a, b, c, d, e) (a', b, c, d, e) a a'
    -> Lens (a, b, c, d, e) (a', b, c, d, e) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e) -> a -> f a'
    k a
    a f a' -> (a' -> (a', b, c, d, e)) -> f (a', b, c, d, e)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c,d
    d,e
    e)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c,d,e,f) (a',b,c,d,e,f) a a' where
      _1 :: Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
    _1 = LensVL (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
    -> Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
     -> Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a')
    -> LensVL (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
    -> Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) -> a -> f a'
    k a
    a f a' -> (a' -> (a', b, c, d, e, f)) -> f (a', b, c, d, e, f)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c,d
    d,e
    e,f
    f)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c,d,e,f,g) (a',b,c,d,e,f,g) a a' where
      _1 :: Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
    _1 = LensVL (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
    -> Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
     -> Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a')
    -> LensVL (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
    -> Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> a -> f a'
    k a
    a f a' -> (a' -> (a', b, c, d, e, f, g)) -> f (a', b, c, d, e, f, g)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c,d
    d,e
    e,f
    f,g
    g)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c,d,e,f,g,h) (a',b,c,d,e,f,g,h) a a' where
      _1 :: Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
    _1 = LensVL (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
    -> Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
     -> Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a')
    -> LensVL (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
    -> Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> a -> f a'
    k a
    a f a'
    -> (a' -> (a', b, c, d, e, f, g, h)) -> f (a', b, c, d, e, f, g, h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h)
      {-# INLINE[1] _1 #-}

    instance Field1 (a,b,c,d,e,f,g,h,i) (a',b,c,d,e,f,g,h,i) a a' where
      _1 :: Lens (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
    _1 = LensVL
      (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
    forall a b. (a -> b) -> a -> b
    $ \a -> f a'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> a -> f a'
    k a
    a f a'
    -> (a' -> (a', b, c, d, e, f, g, h, i))
    -> f (a', b, c, d, e, f, g, h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \a'
    a' -> (a'
    a',b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i)
      {-# INLINE[1] _1 #-}

    -- | Provides access to the 2nd field of a tuple.
    class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 2nd field of a tuple.
      --
      -- >>> _2 .~ "hello" $ (1,(),3,4)
      -- (1,"hello",3,4)
      --
      -- >>> (1,2,3,4) & _2 %~ (*3)
      -- (1,6,3,4)
      --
      -- >>> traverseOf _2 print (1,2)
      -- 2
      -- (1,())
      _2 :: Lens s t a b
      default _2 :: GPosition 2 s t a b => Lens s t a b
      _2 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @2
      {-# INLINE[1] _2 #-}

    instance Field2 (Product f g a) (Product f g' a) (g a) (g' a) where
      _2 :: Lens (Product f g a) (Product f g' a) (g a) (g' a)
    _2 = LensVL (Product f g a) (Product f g' a) (g a) (g' a)
    -> Lens (Product f g a) (Product f g' a) (g a) (g' a)
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (Product f g a) (Product f g' a) (g a) (g' a)
     -> Lens (Product f g a) (Product f g' a) (g a) (g' a))
    -> LensVL (Product f g a) (Product f g' a) (g a) (g' a)
    -> Lens (Product f g a) (Product f g' a) (g a) (g' a)
    forall a b. (a -> b) -> a -> b
    $ \g a -> f (g' a)
    f ~(Pair f a
    a g a
    b) -> f a -> g' a -> Product f g' a
    forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
    f a -> g a -> Product f g a
    Pair f a
    a (g' a -> Product f g' a) -> f (g' a) -> f (Product f g' a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> g a -> f (g' a)
    f g a
    b
      {-# INLINE[1] _2 #-}

    instance Field2 ((f :*: g) p) ((f :*: g') p) (g p) (g' p) where
      _2 :: Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
    _2 = LensVL ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
    -> Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
     -> Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p))
    -> LensVL ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
    -> Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
    forall a b. (a -> b) -> a -> b
    $ \g p -> f (g' p)
    f ~(f p
    l :*: g p
    r) -> (f p
    l f p -> g' p -> (:*:) f g' p
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*:) (g' p -> (:*:) f g' p) -> f (g' p) -> f ((:*:) f g' p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> g p -> f (g' p)
    f g p
    r
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b) (a,b') b b' where
      _2 :: Lens (a, b) (a, b') b b'
    _2 = LensVL (a, b) (a, b') b b' -> Lens (a, b) (a, b') b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b) (a, b') b b' -> Lens (a, b) (a, b') b b')
    -> LensVL (a, b) (a, b') b b' -> Lens (a, b) (a, b') b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b) -> b -> f b'
    k b
    b f b' -> (b' -> (a, b')) -> f (a, b')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b')
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c) (a,b',c) b b' where
      _2 :: Lens (a, b, c) (a, b', c) b b'
    _2 = LensVL (a, b, c) (a, b', c) b b' -> Lens (a, b, c) (a, b', c) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c) (a, b', c) b b'
     -> Lens (a, b, c) (a, b', c) b b')
    -> LensVL (a, b, c) (a, b', c) b b'
    -> Lens (a, b, c) (a, b', c) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c) -> b -> f b'
    k b
    b f b' -> (b' -> (a, b', c)) -> f (a, b', c)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c)
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c,d) (a,b',c,d) b b' where
      _2 :: Lens (a, b, c, d) (a, b', c, d) b b'
    _2 = LensVL (a, b, c, d) (a, b', c, d) b b'
    -> Lens (a, b, c, d) (a, b', c, d) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d) (a, b', c, d) b b'
     -> Lens (a, b, c, d) (a, b', c, d) b b')
    -> LensVL (a, b, c, d) (a, b', c, d) b b'
    -> Lens (a, b, c, d) (a, b', c, d) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c,d
    d) -> b -> f b'
    k b
    b f b' -> (b' -> (a, b', c, d)) -> f (a, b', c, d)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c,d
    d)
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c,d,e) (a,b',c,d,e) b b' where
      _2 :: Lens (a, b, c, d, e) (a, b', c, d, e) b b'
    _2 = LensVL (a, b, c, d, e) (a, b', c, d, e) b b'
    -> Lens (a, b, c, d, e) (a, b', c, d, e) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e) (a, b', c, d, e) b b'
     -> Lens (a, b, c, d, e) (a, b', c, d, e) b b')
    -> LensVL (a, b, c, d, e) (a, b', c, d, e) b b'
    -> Lens (a, b, c, d, e) (a, b', c, d, e) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e) -> b -> f b'
    k b
    b f b' -> (b' -> (a, b', c, d, e)) -> f (a, b', c, d, e)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c,d
    d,e
    e)
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c,d,e,f) (a,b',c,d,e,f) b b' where
      _2 :: Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
    _2 = LensVL (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
    -> Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
     -> Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b')
    -> LensVL (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
    -> Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) -> b -> f b'
    k b
    b f b' -> (b' -> (a, b', c, d, e, f)) -> f (a, b', c, d, e, f)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c,d
    d,e
    e,f
    f)
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c,d,e,f,g) (a,b',c,d,e,f,g) b b' where
      _2 :: Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
    _2 = LensVL (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
    -> Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
     -> Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b')
    -> LensVL (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
    -> Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> b -> f b'
    k b
    b f b' -> (b' -> (a, b', c, d, e, f, g)) -> f (a, b', c, d, e, f, g)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c,d
    d,e
    e,f
    f,g
    g)
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c,d,e,f,g,h) (a,b',c,d,e,f,g,h) b b' where
      _2 :: Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
    _2 = LensVL (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
    -> Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
     -> Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
    -> Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> b -> f b'
    k b
    b f b'
    -> (b' -> (a, b', c, d, e, f, g, h)) -> f (a, b', c, d, e, f, g, h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c,d
    d,e
    e,f
    f,g
    g,h
    h)
      {-# INLINE[1] _2 #-}

    instance Field2 (a,b,c,d,e,f,g,h,i) (a,b',c,d,e,f,g,h,i) b b' where
      _2 :: Lens (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
    _2 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
    forall a b. (a -> b) -> a -> b
    $ \b -> f b'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> b -> f b'
    k b
    b f b'
    -> (b' -> (a, b', c, d, e, f, g, h, i))
    -> f (a, b', c, d, e, f, g, h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \b'
    b' -> (a
    a,b'
    b',c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i)
      {-# INLINE[1] _2 #-}

    -- | Provides access to the 3rd field of a tuple.
    class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 3rd field of a tuple.
      _3 :: Lens s t a b
      default _3 :: GPosition 3 s t a b => Lens s t a b
      _3 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @3
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c) (a,b,c') c c' where
      _3 :: Lens (a, b, c) (a, b, c') c c'
    _3 = LensVL (a, b, c) (a, b, c') c c' -> Lens (a, b, c) (a, b, c') c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c) (a, b, c') c c'
     -> Lens (a, b, c) (a, b, c') c c')
    -> LensVL (a, b, c) (a, b, c') c c'
    -> Lens (a, b, c) (a, b, c') c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c) -> c -> f c'
    k c
    c f c' -> (c' -> (a, b, c')) -> f (a, b, c')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c')
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c,d) (a,b,c',d) c c' where
      _3 :: Lens (a, b, c, d) (a, b, c', d) c c'
    _3 = LensVL (a, b, c, d) (a, b, c', d) c c'
    -> Lens (a, b, c, d) (a, b, c', d) c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d) (a, b, c', d) c c'
     -> Lens (a, b, c, d) (a, b, c', d) c c')
    -> LensVL (a, b, c, d) (a, b, c', d) c c'
    -> Lens (a, b, c, d) (a, b, c', d) c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c,d
    d) -> c -> f c'
    k c
    c f c' -> (c' -> (a, b, c', d)) -> f (a, b, c', d)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c',d
    d)
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c,d,e) (a,b,c',d,e) c c' where
      _3 :: Lens (a, b, c, d, e) (a, b, c', d, e) c c'
    _3 = LensVL (a, b, c, d, e) (a, b, c', d, e) c c'
    -> Lens (a, b, c, d, e) (a, b, c', d, e) c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e) (a, b, c', d, e) c c'
     -> Lens (a, b, c, d, e) (a, b, c', d, e) c c')
    -> LensVL (a, b, c, d, e) (a, b, c', d, e) c c'
    -> Lens (a, b, c, d, e) (a, b, c', d, e) c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e) -> c -> f c'
    k c
    c f c' -> (c' -> (a, b, c', d, e)) -> f (a, b, c', d, e)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c',d
    d,e
    e)
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c,d,e,f) (a,b,c',d,e,f) c c' where
      _3 :: Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
    _3 = LensVL (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
    -> Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
     -> Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c')
    -> LensVL (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
    -> Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) -> c -> f c'
    k c
    c f c' -> (c' -> (a, b, c', d, e, f)) -> f (a, b, c', d, e, f)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c',d
    d,e
    e,f
    f)
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c,d,e,f,g) (a,b,c',d,e,f,g) c c' where
      _3 :: Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
    _3 = LensVL (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
    -> Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
     -> Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c')
    -> LensVL (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
    -> Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> c -> f c'
    k c
    c f c' -> (c' -> (a, b, c', d, e, f, g)) -> f (a, b, c', d, e, f, g)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c',d
    d,e
    e,f
    f,g
    g)
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c,d,e,f,g,h) (a,b,c',d,e,f,g,h) c c' where
      _3 :: Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
    _3 = LensVL (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
     -> Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> c -> f c'
    k c
    c f c'
    -> (c' -> (a, b, c', d, e, f, g, h)) -> f (a, b, c', d, e, f, g, h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c',d
    d,e
    e,f
    f,g
    g,h
    h)
      {-# INLINE[1] _3 #-}

    instance Field3 (a,b,c,d,e,f,g,h,i) (a,b,c',d,e,f,g,h,i) c c' where
      _3 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
    _3 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
    forall a b. (a -> b) -> a -> b
    $ \c -> f c'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> c -> f c'
    k c
    c f c'
    -> (c' -> (a, b, c', d, e, f, g, h, i))
    -> f (a, b, c', d, e, f, g, h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \c'
    c' -> (a
    a,b
    b,c'
    c',d
    d,e
    e,f
    f,g
    g,h
    h,i
    i)
      {-# INLINE[1] _3 #-}

    -- | Provide access to the 4th field of a tuple.
    class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 4th field of a tuple.
      _4 :: Lens s t a b
      default _4 :: GPosition 4 s t a b => Lens s t a b
      _4 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @4
      {-# INLINE[1] _4 #-}

    instance Field4 (a,b,c,d) (a,b,c,d') d d' where
      _4 :: Lens (a, b, c, d) (a, b, c, d') d d'
    _4 = LensVL (a, b, c, d) (a, b, c, d') d d'
    -> Lens (a, b, c, d) (a, b, c, d') d d'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d) (a, b, c, d') d d'
     -> Lens (a, b, c, d) (a, b, c, d') d d')
    -> LensVL (a, b, c, d) (a, b, c, d') d d'
    -> Lens (a, b, c, d) (a, b, c, d') d d'
    forall a b. (a -> b) -> a -> b
    $ \d -> f d'
    k ~(a
    a,b
    b,c
    c,d
    d) -> d -> f d'
    k d
    d f d' -> (d' -> (a, b, c, d')) -> f (a, b, c, d')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \d'
    d' -> (a
    a,b
    b,c
    c,d'
    d')
      {-# INLINE[1] _4 #-}

    instance Field4 (a,b,c,d,e) (a,b,c,d',e) d d' where
      _4 :: Lens (a, b, c, d, e) (a, b, c, d', e) d d'
    _4 = LensVL (a, b, c, d, e) (a, b, c, d', e) d d'
    -> Lens (a, b, c, d, e) (a, b, c, d', e) d d'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e) (a, b, c, d', e) d d'
     -> Lens (a, b, c, d, e) (a, b, c, d', e) d d')
    -> LensVL (a, b, c, d, e) (a, b, c, d', e) d d'
    -> Lens (a, b, c, d, e) (a, b, c, d', e) d d'
    forall a b. (a -> b) -> a -> b
    $ \d -> f d'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e) -> d -> f d'
    k d
    d f d' -> (d' -> (a, b, c, d', e)) -> f (a, b, c, d', e)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \d'
    d' -> (a
    a,b
    b,c
    c,d'
    d',e
    e)
      {-# INLINE[1] _4 #-}

    instance Field4 (a,b,c,d,e,f) (a,b,c,d',e,f) d d' where
      _4 :: Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
    _4 = LensVL (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
    -> Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
     -> Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d')
    -> LensVL (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
    -> Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
    forall a b. (a -> b) -> a -> b
    $ \d -> f d'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) -> d -> f d'
    k d
    d f d' -> (d' -> (a, b, c, d', e, f)) -> f (a, b, c, d', e, f)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \d'
    d' -> (a
    a,b
    b,c
    c,d'
    d',e
    e,f
    f)
      {-# INLINE[1] _4 #-}

    instance Field4 (a,b,c,d,e,f,g) (a,b,c,d',e,f,g) d d' where
      _4 :: Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
    _4 = LensVL (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
     -> Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d')
    -> LensVL (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
    forall a b. (a -> b) -> a -> b
    $ \d -> f d'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> d -> f d'
    k d
    d f d' -> (d' -> (a, b, c, d', e, f, g)) -> f (a, b, c, d', e, f, g)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \d'
    d' -> (a
    a,b
    b,c
    c,d'
    d',e
    e,f
    f,g
    g)
      {-# INLINE[1] _4 #-}

    instance Field4 (a,b,c,d,e,f,g,h) (a,b,c,d',e,f,g,h) d d' where
      _4 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
    _4 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
     -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
    forall a b. (a -> b) -> a -> b
    $ \d -> f d'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> d -> f d'
    k d
    d f d'
    -> (d' -> (a, b, c, d', e, f, g, h)) -> f (a, b, c, d', e, f, g, h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \d'
    d' -> (a
    a,b
    b,c
    c,d'
    d',e
    e,f
    f,g
    g,h
    h)
      {-# INLINE[1] _4 #-}

    instance Field4 (a,b,c,d,e,f,g,h,i) (a,b,c,d',e,f,g,h,i) d d' where
      _4 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
    _4 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
    forall a b. (a -> b) -> a -> b
    $ \d -> f d'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> d -> f d'
    k d
    d f d'
    -> (d' -> (a, b, c, d', e, f, g, h, i))
    -> f (a, b, c, d', e, f, g, h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \d'
    d' -> (a
    a,b
    b,c
    c,d'
    d',e
    e,f
    f,g
    g,h
    h,i
    i)
      {-# INLINE[1] _4 #-}

    -- | Provides access to the 5th field of a tuple.
    class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 5th field of a tuple.
      _5 :: Lens s t a b
      default _5 :: GPosition 5 s t a b => Lens s t a b
      _5 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @5
      {-# INLINE[1] _5 #-}

    instance Field5 (a,b,c,d,e) (a,b,c,d,e') e e' where
      _5 :: Lens (a, b, c, d, e) (a, b, c, d, e') e e'
    _5 = LensVL (a, b, c, d, e) (a, b, c, d, e') e e'
    -> Lens (a, b, c, d, e) (a, b, c, d, e') e e'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e) (a, b, c, d, e') e e'
     -> Lens (a, b, c, d, e) (a, b, c, d, e') e e')
    -> LensVL (a, b, c, d, e) (a, b, c, d, e') e e'
    -> Lens (a, b, c, d, e) (a, b, c, d, e') e e'
    forall a b. (a -> b) -> a -> b
    $ \e -> f e'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e) -> e -> f e'
    k e
    e f e' -> (e' -> (a, b, c, d, e')) -> f (a, b, c, d, e')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \e'
    e' -> (a
    a,b
    b,c
    c,d
    d,e'
    e')
      {-# INLINE[1] _5 #-}

    instance Field5 (a,b,c,d,e,f) (a,b,c,d,e',f) e e' where
      _5 :: Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
    _5 = LensVL (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
    -> Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
     -> Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e')
    -> LensVL (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
    -> Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
    forall a b. (a -> b) -> a -> b
    $ \e -> f e'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) -> e -> f e'
    k e
    e f e' -> (e' -> (a, b, c, d, e', f)) -> f (a, b, c, d, e', f)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \e'
    e' -> (a
    a,b
    b,c
    c,d
    d,e'
    e',f
    f)
      {-# INLINE[1] _5 #-}

    instance Field5 (a,b,c,d,e,f,g) (a,b,c,d,e',f,g) e e' where
      _5 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
    _5 = LensVL (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
     -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e')
    -> LensVL (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
    forall a b. (a -> b) -> a -> b
    $ \e -> f e'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> e -> f e'
    k e
    e f e' -> (e' -> (a, b, c, d, e', f, g)) -> f (a, b, c, d, e', f, g)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \e'
    e' -> (a
    a,b
    b,c
    c,d
    d,e'
    e',f
    f,g
    g)
      {-# INLINE[1] _5 #-}

    instance Field5 (a,b,c,d,e,f,g,h) (a,b,c,d,e',f,g,h) e e' where
      _5 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
    _5 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
     -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
    forall a b. (a -> b) -> a -> b
    $ \e -> f e'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> e -> f e'
    k e
    e f e'
    -> (e' -> (a, b, c, d, e', f, g, h)) -> f (a, b, c, d, e', f, g, h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \e'
    e' -> (a
    a,b
    b,c
    c,d
    d,e'
    e',f
    f,g
    g,h
    h)
      {-# INLINE[1] _5 #-}

    instance Field5 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e',f,g,h,i) e e' where
      _5 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
    _5 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
    forall a b. (a -> b) -> a -> b
    $ \e -> f e'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> e -> f e'
    k e
    e f e'
    -> (e' -> (a, b, c, d, e', f, g, h, i))
    -> f (a, b, c, d, e', f, g, h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \e'
    e' -> (a
    a,b
    b,c
    c,d
    d,e'
    e',f
    f,g
    g,h
    h,i
    i)
      {-# INLINE[1] _5 #-}

    -- | Provides access to the 6th element of a tuple.
    class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 6th field of a tuple.
      _6 :: Lens s t a b
      default _6 :: GPosition 6 s t a b => Lens s t a b
      _6 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @6
      {-# INLINE[1] _6 #-}

    instance Field6 (a,b,c,d,e,f) (a,b,c,d,e,f') f f' where
      _6 :: Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
    _6 = LensVL (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
    -> Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
     -> Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f')
    -> LensVL (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
    -> Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
    forall a b. (a -> b) -> a -> b
    $ \f -> f f'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f) -> f -> f f'
    k f
    f f f' -> (f' -> (a, b, c, d, e, f')) -> f (a, b, c, d, e, f')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \f'
    f' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f'
    f')
      {-# INLINE[1] _6 #-}

    instance Field6 (a,b,c,d,e,f,g) (a,b,c,d,e,f',g) f f' where
      _6 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
    _6 = LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
     -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f')
    -> LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
    forall a b. (a -> b) -> a -> b
    $ \f -> f f'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> f -> f f'
    k f
    f f f' -> (f' -> (a, b, c, d, e, f', g)) -> f (a, b, c, d, e, f', g)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \f'
    f' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f'
    f',g
    g)
      {-# INLINE[1] _6 #-}

    instance Field6 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f',g,h) f f' where
      _6 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
    _6 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
     -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
    forall a b. (a -> b) -> a -> b
    $ \f -> f f'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> f -> f f'
    k f
    f f f'
    -> (f' -> (a, b, c, d, e, f', g, h)) -> f (a, b, c, d, e, f', g, h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \f'
    f' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f'
    f',g
    g,h
    h)
      {-# INLINE[1] _6 #-}

    instance Field6 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f',g,h,i) f f' where
      _6 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
    _6 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
    forall a b. (a -> b) -> a -> b
    $ \f -> f f'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> f -> f f'
    k f
    f f f'
    -> (f' -> (a, b, c, d, e, f', g, h, i))
    -> f (a, b, c, d, e, f', g, h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \f'
    f' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f'
    f',g
    g,h
    h,i
    i)
      {-# INLINE[1] _6 #-}

    -- | Provide access to the 7th field of a tuple.
    class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 7th field of a tuple.
      _7 :: Lens s t a b
      default _7 :: GPosition 7 s t a b => Lens s t a b
      _7 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @7
      {-# INLINE[1] _7 #-}

    instance Field7 (a,b,c,d,e,f,g) (a,b,c,d,e,f,g') g g' where
      _7 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
    _7 = LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
     -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g')
    -> LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
    -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
    forall a b. (a -> b) -> a -> b
    $ \g -> f g'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g) -> g -> f g'
    k g
    g f g' -> (g' -> (a, b, c, d, e, f, g')) -> f (a, b, c, d, e, f, g')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \g'
    g' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g'
    g')
      {-# INLINE[1] _7 #-}

    instance Field7 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f,g',h) g g' where
      _7 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
    _7 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
     -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
    forall a b. (a -> b) -> a -> b
    $ \g -> f g'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> g -> f g'
    k g
    g f g'
    -> (g' -> (a, b, c, d, e, f, g', h)) -> f (a, b, c, d, e, f, g', h)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \g'
    g' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g'
    g',h
    h)
      {-# INLINE[1] _7 #-}

    instance Field7 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g',h,i) g g' where
      _7 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
    _7 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
    forall a b. (a -> b) -> a -> b
    $ \g -> f g'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> g -> f g'
    k g
    g f g'
    -> (g' -> (a, b, c, d, e, f, g', h, i))
    -> f (a, b, c, d, e, f, g', h, i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \g'
    g' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g'
    g',h
    h,i
    i)
      {-# INLINE[1] _7 #-}

    -- | Provide access to the 8th field of a tuple.
    class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 8th field of a tuple.
      _8 :: Lens s t a b
      default _8 :: GPosition 8 s t a b => Lens s t a b
      _8 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @8
      {-# INLINE[1] _8 #-}

    instance Field8 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f,g,h') h h' where
      _8 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
    _8 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
     -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h')
    -> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
    -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
    forall a b. (a -> b) -> a -> b
    $ \h -> f h'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h) -> h -> f h'
    k h
    h f h'
    -> (h' -> (a, b, c, d, e, f, g, h')) -> f (a, b, c, d, e, f, g, h')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \h'
    h' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h'
    h')
      {-# INLINE[1] _8 #-}

    instance Field8 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h',i) h h' where
      _8 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
    _8 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
    forall a b. (a -> b) -> a -> b
    $ \h -> f h'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> h -> f h'
    k h
    h f h'
    -> (h' -> (a, b, c, d, e, f, g, h', i))
    -> f (a, b, c, d, e, f, g, h', i)
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \h'
    h' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h'
    h',i
    i)
      {-# INLINE[1] _8 #-}

    -- | Provides access to the 9th field of a tuple.
    class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where
      -- | Access the 9th field of a tuple.
      _9 :: Lens s t a b
      default _9 :: GPosition 9 s t a b => Lens s t a b
      _9 = forall (n :: Nat) s t a b. GPosition n s t a b => Lens s t a b
    gposition @9
      {-# INLINE[1] _9 #-}

    instance Field9 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h,i') i i' where
      _9 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
    _9 = LensVL
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
    forall s t a b. LensVL s t a b -> Lens s t a b
    lensVL (LensVL
       (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
     -> Lens
          (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i')
    -> LensVL
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
    -> Lens
         (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
    forall a b. (a -> b) -> a -> b
    $ \i -> f i'
    k ~(a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i
    i) -> i -> f i'
    k i
    i f i'
    -> (i' -> (a, b, c, d, e, f, g, h, i'))
    -> f (a, b, c, d, e, f, g, h, i')
    forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
    <&> \i'
    i' -> (a
    a,b
    b,c
    c,d
    d,e
    e,f
    f,g
    g,h
    h,i'
    i')
      {-# INLINE[1] _9 #-}

    -- Strict versions of the _1 .. _9 operations

    -- | Strict version of '_1'
    _1' :: Field1 s t a b => Lens s t a b
    _1' :: forall s t a b. Field1 s t a b => Lens s t a b
    _1' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field1 s t a b => Lens s t a b
    _1
    {-# INLINE _1' #-}

    -- | Strict version of '_2'
    _2' :: Field2 s t a b => Lens s t a b
    _2' :: forall s t a b. Field2 s t a b => Lens s t a b
    _2' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field2 s t a b => Lens s t a b
    _2
    {-# INLINE _2' #-}

    -- | Strict version of '_3'
    _3' :: Field3 s t a b => Lens s t a b
    _3' :: forall s t a b. Field3 s t a b => Lens s t a b
    _3' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field3 s t a b => Lens s t a b
    _3
    {-# INLINE _3' #-}

    -- | Strict version of '_4'
    _4' :: Field4 s t a b => Lens s t a b
    _4' :: forall s t a b. Field4 s t a b => Lens s t a b
    _4' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field4 s t a b => Lens s t a b
    _4
    {-# INLINE _4' #-}

    -- | Strict version of '_5'
    _5' :: Field5 s t a b => Lens s t a b
    _5' :: forall s t a b. Field5 s t a b => Lens s t a b
    _5' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field5 s t a b => Lens s t a b
    _5
    {-# INLINE _5' #-}

    -- | Strict version of '_6'
    _6' :: Field6 s t a b => Lens s t a b
    _6' :: forall s t a b. Field6 s t a b => Lens s t a b
    _6' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field6 s t a b => Lens s t a b
    _6
    {-# INLINE _6' #-}

    -- | Strict version of '_7'
    _7' :: Field7 s t a b => Lens s t a b
    _7' :: forall s t a b. Field7 s t a b => Lens s t a b
    _7' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field7 s t a b => Lens s t a b
    _7
    {-# INLINE _7' #-}

    -- | Strict version of '_8'
    _8' :: Field8 s t a b => Lens s t a b
    _8' :: forall s t a b. Field8 s t a b => Lens s t a b
    _8' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field8 s t a b => Lens s t a b
    _8
    {-# INLINE _8' #-}

    -- | Strict version of '_9'
    _9' :: Field9 s t a b => Lens s t a b
    _9' :: forall s t a b. Field9 s t a b => Lens s t a b
    _9' = Lens s t s t
    forall a b. Lens a b a b
    equality' Lens s t s t
    -> Optic A_Lens NoIx s t a b -> Optic A_Lens NoIx s t a b
    forall k l m (is :: IxList) (js :: IxList) (ks :: IxList) s t u v a
           b.
    (JoinKinds k l m, AppendIndices is js ks) =>
    Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
    % Optic A_Lens NoIx s t a b
    forall s t a b. Field9 s t a b => Lens s t a b
    _9
    {-# INLINE _9' #-}

    -- $setup
    -- >>> import Optics.Core