    {-# OPTIONS_GHC -fno-warn-orphans #-}
    {-# LANGUAGE UndecidableInstances #-}

    module Agda.TypeChecking.Serialise.Instances.Common (SerialisedRange(..)) where

    import qualified Control.Exception as E
    import Control.Monad              ( (<=<), (<$!>) )
    import Control.Monad.IO.Class     ( MonadIO(..) )
    import Control.Monad.Except       ( MonadError(..) )
    import Control.Monad.Reader       ( MonadReader(..), asks )
    import Control.Monad.State        ( runStateT )
    import Control.Monad.State.Strict ( gets, modify )

    import Data.Array.IArray
    import qualified Data.Foldable as Fold
    import Data.Hashable
    import Data.HashMap.Strict (HashMap)
    import qualified Data.HashMap.Strict as HMap
    import Data.Int (Int32)
    import Data.IntSet (IntSet)
    import qualified Data.IntSet as IntSet
    import Data.Map (Map)
    import qualified Data.Map as Map
    import Data.Sequence (Seq)
    import qualified Data.Sequence as Seq
    import Data.Set (Set)
    import qualified Data.Set as Set
    import Data.Strict.Tuple (Pair(..))
    import qualified Data.Text      as T
    import qualified Data.Text.Lazy as TL
    import Data.Typeable
    import Data.Void
    import Data.Word (Word32, Word64)

    import Agda.Syntax.Common
    import Agda.Syntax.Builtin
    import Agda.Syntax.Concrete.Name as C
    import Agda.Syntax.Concrete (RecordDirective(..))
    import qualified Agda.Syntax.Concrete as C
    import qualified Agda.Syntax.Abstract as A
    import Agda.Syntax.Position as P
    import Agda.Syntax.Literal
    import Agda.Syntax.TopLevelModuleName
    import Agda.Interaction.FindFile
    import Agda.Interaction.Library

    import Agda.TypeChecking.Monad.Base.Types
    import Agda.TypeChecking.Serialise.Base

    import Agda.Utils.BiMap (BiMap)
    import qualified Agda.Utils.BiMap as BiMap
    import Agda.Utils.FileId (getIdFile)
    import Agda.Utils.List1 (List1)
    import qualified Agda.Utils.List1 as List1
    import Agda.Utils.List2 (List2(List2))
    import qualified Agda.Utils.List2 as List2
    import qualified Agda.Utils.Maybe.Strict as Strict
    import Agda.Utils.Null
    import Agda.Utils.SmallSet (SmallSet(..))
    import Agda.Utils.Set1 (Set1)
    import qualified Agda.Utils.Set1 as Set1
    import Agda.Utils.Trie (Trie(..))
    import Agda.Utils.WithDefault

    import Agda.Utils.Impossible
    import Agda.Utils.CallStack

    instance {-# OVERLAPPING #-} EmbPrj String where
      icod_ :: String -> S Word32
    icod_   = String -> S Word32
    icodeString
      value :: Word32 -> R String
    value Word32
    i = (Array Word32 String -> Word32 -> String
    forall (a :: * -> * -> *) e i.
    (IArray a e, Ix i) =>
    a i e -> i -> e
    ! Word32
    i) (Array Word32 String -> String)
    -> StateT St IO (Array Word32 String) -> R String
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> (St -> Array Word32 String) -> StateT St IO (Array Word32 String)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets St -> Array Word32 String
    stringE

    instance EmbPrj TL.Text where
      icod_ :: Text -> S Word32
    icod_   = (Dict -> HashTable Text Word32)
    -> (Dict -> IORef FreshAndReuse) -> Text -> S Word32
    forall k.
    (Eq k, Hashable k) =>
    (Dict -> HashTable k Word32)
    -> (Dict -> IORef FreshAndReuse) -> k -> S Word32
    icodeX Dict -> HashTable Text Word32
    lTextD Dict -> IORef FreshAndReuse
    lTextC
      value :: Word32 -> R Text
    value Word32
    i = (Array Word32 Text -> Word32 -> Text
    forall (a :: * -> * -> *) e i.
    (IArray a e, Ix i) =>
    a i e -> i -> e
    ! Word32
    i) (Array Word32 Text -> Text)
    -> StateT St IO (Array Word32 Text) -> R Text
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> (St -> Array Word32 Text) -> StateT St IO (Array Word32 Text)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets St -> Array Word32 Text
    lTextE

    instance EmbPrj T.Text where
      icod_ :: Text -> S Word32
    icod_   = (Dict -> HashTable Text Word32)
    -> (Dict -> IORef FreshAndReuse) -> Text -> S Word32
    forall k.
    (Eq k, Hashable k) =>
    (Dict -> HashTable k Word32)
    -> (Dict -> IORef FreshAndReuse) -> k -> S Word32
    icodeX Dict -> HashTable Text Word32
    sTextD Dict -> IORef FreshAndReuse
    sTextC
      value :: Word32 -> R Text
    value Word32
    i = (Array Word32 Text -> Word32 -> Text
    forall (a :: * -> * -> *) e i.
    (IArray a e, Ix i) =>
    a i e -> i -> e
    ! Word32
    i) (Array Word32 Text -> Text)
    -> StateT St IO (Array Word32 Text) -> R Text
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> (St -> Array Word32 Text) -> StateT St IO (Array Word32 Text)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets St -> Array Word32 Text
    sTextE

    instance EmbPrj Integer where
      icod_ :: Integer -> S Word32
    icod_   = Integer -> S Word32
    icodeInteger
      value :: Word32 -> R Integer
    value Word32
    i = (Array Word32 Integer -> Word32 -> Integer
    forall (a :: * -> * -> *) e i.
    (IArray a e, Ix i) =>
    a i e -> i -> e
    ! Word32
    i) (Array Word32 Integer -> Integer)
    -> StateT St IO (Array Word32 Integer) -> R Integer
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> (St -> Array Word32 Integer) -> StateT St IO (Array Word32 Integer)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets St -> Array Word32 Integer
    integerE

    instance EmbPrj Word64 where
      icod_ :: Word64 -> S Word32
    icod_ Word64
    i = (Word32 -> Word32 -> Word32)
    -> Arrows (Domains (Word32 -> Word32 -> Word32)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' (Word32 -> Word32 -> Word32
    forall a. HasCallStack => a
    undefined :: Word32 -> Word32 -> Word32) (Word64 -> Word32
    word32 Word64
    q) (Word64 -> Word32
    word32 Word64
    r)
        where (Word64
    q, Word64
    r) = Word64 -> Word64 -> (Word64, Word64)
    forall a. Integral a => a -> a -> (a, a)
    quotRem Word64
    i (Word64
    2 Word64 -> Integer -> Word64
    forall a b. (Num a, Integral b) => a -> b -> a
    ^ Integer
    32)
              word32 :: Word64 -> Word32
              word32 :: Word64 -> Word32
    word32 = Word64 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

      value :: Word32 -> R Word64
    value = ([Word32] -> R Word64) -> Word32 -> R Word64
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Word64
    valu where
        valu :: [Word32] -> R Word64
    valu [Word32
    a, Word32
    b] = Word64 -> R Word64
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> R Word64) -> Word64 -> R Word64
    forall a b. (a -> b) -> a -> b
    $! Word64
    n Word64 -> Word64 -> Word64
    forall a. Num a => a -> a -> a
    * Word32 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word32
    a Word64 -> Word64 -> Word64
    forall a. Num a => a -> a -> a
    + Word32 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word32
    b
        valu [Word32]
    _      = R Word64
    forall a. R a
    malformed
        n :: Word64
    n = Word64
    2 Word64 -> Integer -> Word64
    forall a b. (Num a, Integral b) => a -> b -> a
    ^ Integer
    32

    instance EmbPrj Word32 where
      icod_ :: Word32 -> S Word32
    icod_ Word32
    i = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    i
      value :: Word32 -> R Word32
    value Word32
    i = Word32 -> R Word32
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    i

    -- Andreas, Agda Hackathon 2024-10-15
    -- Are we sure we never use an Int that does not fit into 32 bits?
    instance EmbPrj Int where
      icod_ :: Int -> S Word32
    icod_ Int
    i = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> S Word32) -> Word32 -> S Word32
    forall a b. (a -> b) -> a -> b
    $! Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int
    i
      value :: Word32 -> R Int
    value Word32
    i = Int -> R Int
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> R Int) -> Int -> R Int
    forall a b. (a -> b) -> a -> b
    $! Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word32
    i

    instance EmbPrj Int32 where
      icod_ :: Int32 -> S Word32
    icod_ Int32
    i = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> S Word32) -> Word32 -> S Word32
    forall a b. (a -> b) -> a -> b
    $! Int32 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Int32
    i
      value :: Word32 -> R Int32
    value Word32
    i = Int32 -> R Int32
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> R Int32) -> Int32 -> R Int32
    forall a b. (a -> b) -> a -> b
    $! Word32 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral Word32
    i

    instance EmbPrj Char where
      icod_ :: Char -> S Word32
    icod_ Char
    c = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> S Word32) -> Word32 -> S Word32
    forall a b. (a -> b) -> a -> b
    $! Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word32) -> Int -> Word32
    forall a b. (a -> b) -> a -> b
    $ Char -> Int
    forall a. Enum a => a -> Int
    fromEnum Char
    c
      value :: Word32 -> R Char
    value Word32
    i = Char -> R Char
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> R Char) -> Char -> R Char
    forall a b. (a -> b) -> a -> b
    $! Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> Int -> Char
    forall a b. (a -> b) -> a -> b
    $ Integer -> Int
    forall a. Num a => Integer -> a
    fromInteger (Integer -> Int) -> Integer -> Int
    forall a b. (a -> b) -> a -> b
    $ Word32 -> Integer
    forall a. Integral a => a -> Integer
    toInteger Word32
    i

    instance EmbPrj Double where
      icod_ :: Double -> S Word32
    icod_   = Double -> S Word32
    icodeDouble
      value :: Word32 -> R Double
    value Word32
    i = (Array Word32 Double -> Word32 -> Double
    forall (a :: * -> * -> *) e i.
    (IArray a e, Ix i) =>
    a i e -> i -> e
    ! Word32
    i) (Array Word32 Double -> Double)
    -> StateT St IO (Array Word32 Double) -> R Double
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> (St -> Array Word32 Double) -> StateT St IO (Array Word32 Double)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets St -> Array Word32 Double
    doubleE

    instance EmbPrj Void where
      icod_ :: Void -> S Word32
    icod_ = Void -> S Word32
    forall a. Void -> a
    absurd
      value :: Word32 -> R Void
    value = ([Word32] -> R Void) -> Word32 -> R Void
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Void
    forall {p} {a}. p -> R a
    valu where valu :: p -> R a
    valu p
    _ = R a
    forall a. R a
    malformed

    instance EmbPrj () where
      icod_ :: () -> S Word32
    icod_ () = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    0

      value :: Word32 -> R ()
    value Word32
    0 = () -> R ()
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
      value Word32
    _ = R ()
    forall a. R a
    malformed

    instance (EmbPrj a, EmbPrj b) => EmbPrj (a, b) where
      icod_ :: (a, b) -> S Word32
    icod_ (a
    a, b
    b) = (a -> b -> (a, b))
    -> Arrows (Domains (a -> b -> (a, b))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' (,) a
    a b
    b

      value :: Word32 -> R (a, b)
    value = (a -> b -> (a, b)) -> Word32 -> R (CoDomain (a -> b -> (a, b)))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN (,)

    instance (EmbPrj a, EmbPrj b) => EmbPrj (Pair a b) where
      icod_ :: Pair a b -> S Word32
    icod_ (a
    a :!: b
    b) = (a -> b -> Pair a b)
    -> Arrows (Domains (a -> b -> Pair a b)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' a -> b -> Pair a b
    forall a b. a -> b -> Pair a b
    (:!:) a
    a b
    b

      value :: Word32 -> R (Pair a b)
    value = (a -> b -> Pair a b) -> Word32 -> R (CoDomain (a -> b -> Pair a b))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN a -> b -> Pair a b
    forall a b. a -> b -> Pair a b
    (:!:)

    instance (EmbPrj a, EmbPrj b, EmbPrj c) => EmbPrj (a, b, c) where
      icod_ :: (a, b, c) -> S Word32
    icod_ (a
    a, b
    b, c
    c) = (a -> b -> c -> (a, b, c))
    -> Arrows (Domains (a -> b -> c -> (a, b, c))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' (,,) a
    a b
    b c
    c

      value :: Word32 -> R (a, b, c)
    value = (a -> b -> c -> (a, b, c))
    -> Word32 -> R (CoDomain (a -> b -> c -> (a, b, c)))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN (,,)

    instance (EmbPrj a, EmbPrj b) => EmbPrj (Either a b) where
      icod_ :: Either a b -> S Word32
    icod_ (Left  a
    x) = Word32
    -> (a -> Either a (ZonkAny 8))
    -> Arrows (Domains (a -> Either a (ZonkAny 8))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 a -> Either a (ZonkAny 8)
    forall a b. a -> Either a b
    Left a
    x
      icod_ (Right b
    x) = Word32
    -> (b -> Either (ZonkAny 9) b)
    -> Arrows (Domains (b -> Either (ZonkAny 9) b)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 b -> Either (ZonkAny 9) b
    forall a b. b -> Either a b
    Right b
    x

      value :: Word32 -> R (Either a b)
    value = ([Word32] -> R (Either a b)) -> Word32 -> R (Either a b)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R (Either a b)
    forall {a} {b}. (EmbPrj a, EmbPrj b) => [Word32] -> R (Either a b)
    valu where
        valu :: [Word32] -> R (Either a b)
    valu [Word32
    0, Word32
    x] = (a -> Either a b)
    -> Arrows
         (Constant Word32 (Domains (a -> Either a b)))
         (R (CoDomain (a -> Either a b)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN a -> Either a b
    forall a b. a -> Either a b
    Left  Word32
    x
        valu [Word32
    1, Word32
    x] = (b -> Either a b)
    -> Arrows
         (Constant Word32 (Domains (b -> Either a b)))
         (R (CoDomain (b -> Either a b)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN b -> Either a b
    forall a b. b -> Either a b
    Right Word32
    x
        valu [Word32]
    _   = R (Either a b)
    forall a. R a
    malformed

    instance EmbPrj a => EmbPrj (Maybe a) where
      icod_ :: Maybe a -> S Word32
    icod_ Maybe a
    Nothing  = Maybe (ZonkAny 7)
    -> Arrows (Domains (Maybe (ZonkAny 7))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Maybe (ZonkAny 7)
    forall a. Maybe a
    Nothing
      icod_ (Just a
    x) = (a -> Maybe a) -> Arrows (Domains (a -> Maybe a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' a -> Maybe a
    forall a. a -> Maybe a
    Just a
    x

      value :: Word32 -> R (Maybe a)
    value = ([Word32] -> R (Maybe a)) -> Word32 -> R (Maybe a)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R (Maybe a)
    forall {a}. EmbPrj a => [Word32] -> StateT St IO (Maybe a)
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains (Maybe a))) (R (CoDomain (Maybe a)))
    valu []  = Maybe a
    -> Arrows
         (Constant Word32 (Domains (Maybe a))) (R (CoDomain (Maybe a)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Maybe a
    forall a. Maybe a
    Nothing
        valu [Word32
    x] = (a -> Maybe a)
    -> Arrows
         (Constant Word32 (Domains (a -> Maybe a)))
         (R (CoDomain (a -> Maybe a)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN a -> Maybe a
    forall a. a -> Maybe a
    Just Word32
    x
        valu [Word32]
    _   = StateT St IO (Maybe a)
    Arrows
      (Constant Word32 (Domains (Maybe a))) (R (CoDomain (Maybe a)))
    forall a. R a
    malformed

    instance EmbPrj a => EmbPrj (Strict.Maybe a) where
      icod_ :: Maybe a -> S Word32
    icod_ Maybe a
    m = Maybe a -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (Maybe a -> Maybe a
    forall lazy strict. Strict lazy strict => strict -> lazy
    Strict.toLazy Maybe a
    m)
      value :: Word32 -> R (Maybe a)
    value Word32
    m = Maybe a -> Maybe a
    forall lazy strict. Strict lazy strict => lazy -> strict
    Strict.toStrict (Maybe a -> Maybe a) -> StateT St IO (Maybe a) -> R (Maybe a)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO (Maybe a)
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    m

    instance EmbPrj Bool where
      icod_ :: Bool -> S Word32
    icod_ Bool
    False = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    0
      icod_ Bool
    True  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    1

      value :: Word32 -> R Bool
    value Word32
    0 = Bool -> R Bool
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    False
      value Word32
    1 = Bool -> R Bool
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Bool
    True
      value Word32
    _ = R Bool
    forall a. R a
    malformed

    instance EmbPrj ConstructorOrPatternSynonym

    instance EmbPrj FileType where
      icod_ :: FileType -> S Word32
    icod_ FileType
    AgdaFileType  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    0
      icod_ FileType
    MdFileType    = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    1
      icod_ FileType
    RstFileType   = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    2
      icod_ FileType
    TexFileType   = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    3
      icod_ FileType
    OrgFileType   = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    4
      icod_ FileType
    TypstFileType = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    5
      icod_ FileType
    TreeFileType  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    6

      value :: Word32 -> R FileType
    value = \case
        Word32
    0 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    AgdaFileType
        Word32
    1 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    MdFileType
        Word32
    2 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    RstFileType
        Word32
    3 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    TexFileType
        Word32
    4 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    OrgFileType
        Word32
    5 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    TypstFileType
        Word32
    6 -> FileType -> R FileType
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure FileType
    TreeFileType
        Word32
    _ -> R FileType
    forall a. R a
    malformed

    instance EmbPrj Cubical where
      icod_ :: Cubical -> S Word32
    icod_ Cubical
    CErased = Cubical -> Arrows (Domains Cubical) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN'  Cubical
    CErased
      icod_ Cubical
    CFull   = Word32 -> Cubical -> Arrows (Domains Cubical) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 Cubical
    CFull

      value :: Word32 -> R Cubical
    value = ([Word32] -> R Cubical) -> Word32 -> R Cubical
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([Word32] -> R Cubical) -> Word32 -> R Cubical)
    -> ([Word32] -> R Cubical) -> Word32 -> R Cubical
    forall a b. (a -> b) -> a -> b
    $ \case
        []  -> Cubical
    -> Arrows
         (Constant Word32 (Domains Cubical)) (R (CoDomain Cubical))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Cubical
    CErased
        [Word32
    0] -> Cubical
    -> Arrows
         (Constant Word32 (Domains Cubical)) (R (CoDomain Cubical))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Cubical
    CFull
        [Word32]
    _   -> R Cubical
    forall a. R a
    malformed

    instance EmbPrj Language where
      icod_ :: Language -> S Word32
    icod_ Language
    WithoutK    = Language -> Arrows (Domains Language) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN'  Language
    WithoutK
      icod_ Language
    WithK       = Word32 -> Language -> Arrows (Domains Language) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 Language
    WithK
      icod_ (Cubical Cubical
    a) = Word32
    -> (Cubical -> Language)
    -> Arrows (Domains (Cubical -> Language)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Cubical -> Language
    Cubical Cubical
    a

      value :: Word32 -> R Language
    value = ([Word32] -> R Language) -> Word32 -> R Language
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([Word32] -> R Language) -> Word32 -> R Language)
    -> ([Word32] -> R Language) -> Word32 -> R Language
    forall a b. (a -> b) -> a -> b
    $ \case
        []     -> Language
    -> Arrows
         (Constant Word32 (Domains Language)) (R (CoDomain Language))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Language
    WithoutK
        [Word32
    0]    -> Language
    -> Arrows
         (Constant Word32 (Domains Language)) (R (CoDomain Language))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Language
    WithK
        [Word32
    1, Word32
    a] -> (Cubical -> Language)
    -> Arrows
         (Constant Word32 (Domains (Cubical -> Language)))
         (R (CoDomain (Cubical -> Language)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Cubical -> Language
    Cubical Word32
    a
        [Word32]
    _      -> R Language
    forall a. R a
    malformed

    instance EmbPrj a => EmbPrj (Position' a) where
      icod_ :: Position' a -> S Word32
    icod_ (P.Pn a
    file Word32
    pos Word32
    line Word32
    col) = (a -> Word32 -> Word32 -> Word32 -> Position' a)
    -> Arrows
         (Domains (a -> Word32 -> Word32 -> Word32 -> Position' a))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' a -> Word32 -> Word32 -> Word32 -> Position' a
    forall a. a -> Word32 -> Word32 -> Word32 -> Position' a
    P.Pn a
    file Word32
    pos Word32
    line Word32
    col

      value :: Word32 -> R (Position' a)
    value = (a -> Word32 -> Word32 -> Word32 -> Position' a)
    -> Word32
    -> R (CoDomain (a -> Word32 -> Word32 -> Word32 -> Position' a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN a -> Word32 -> Word32 -> Word32 -> Position' a
    forall a. a -> Word32 -> Word32 -> Word32 -> Position' a
    P.Pn

    instance (EmbPrj a, Typeable b) => EmbPrj (WithDefault' a b) where
      icod_ :: WithDefault' a b -> S Word32
    icod_ = \case
        WithDefault' a b
    Default -> WithDefault' (ZonkAny 4) (ZonkAny 5)
    -> Arrows
         (Domains (WithDefault' (ZonkAny 4) (ZonkAny 5))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' WithDefault' (ZonkAny 4) (ZonkAny 5)
    forall a (b :: Bool). WithDefault' a b
    Default
        Value a
    b -> (a -> WithDefault' a (ZonkAny 6))
    -> Arrows (Domains (a -> WithDefault' a (ZonkAny 6))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' a -> WithDefault' a (ZonkAny 6)
    forall a (b :: Bool). a -> WithDefault' a b
    Value a
    b

      value :: Word32 -> R (WithDefault' a b)
    value = ([Word32] -> R (WithDefault' a b))
    -> Word32 -> R (WithDefault' a b)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([Word32] -> R (WithDefault' a b))
     -> Word32 -> R (WithDefault' a b))
    -> ([Word32] -> R (WithDefault' a b))
    -> Word32
    -> R (WithDefault' a b)
    forall a b. (a -> b) -> a -> b
    $ \case
        []  -> WithDefault' a b
    -> Arrows
         (Constant Word32 (Domains (WithDefault' a b)))
         (R (CoDomain (WithDefault' a b)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN WithDefault' a b
    forall a (b :: Bool). WithDefault' a b
    Default
        [Word32
    a] -> (a -> WithDefault' a b)
    -> Arrows
         (Constant Word32 (Domains (a -> WithDefault' a b)))
         (R (CoDomain (a -> WithDefault' a b)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN a -> WithDefault' a b
    forall a (b :: Bool). a -> WithDefault' a b
    Value Word32
    a
        [Word32]
    _ -> R (WithDefault' a b)
    forall a. R a
    malformed

    instance EmbPrj TopLevelModuleName where
      icod_ :: TopLevelModuleName -> S Word32
    icod_ (TopLevelModuleName Range
    a ModuleNameHash
    b TopLevelModuleNameParts
    c Bool
    d) = (Range
     -> ModuleNameHash
     -> TopLevelModuleNameParts
     -> Bool
     -> TopLevelModuleName)
    -> Arrows
         (Domains
            (Range
             -> ModuleNameHash
             -> TopLevelModuleNameParts
             -> Bool
             -> TopLevelModuleName))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Range
    -> ModuleNameHash
    -> TopLevelModuleNameParts
    -> Bool
    -> TopLevelModuleName
    forall range.
    range
    -> ModuleNameHash
    -> TopLevelModuleNameParts
    -> Bool
    -> TopLevelModuleName' range
    TopLevelModuleName Range
    a ModuleNameHash
    b TopLevelModuleNameParts
    c Bool
    d

      value :: Word32 -> R TopLevelModuleName
    value = (Range
     -> ModuleNameHash
     -> TopLevelModuleNameParts
     -> Bool
     -> TopLevelModuleName)
    -> Word32
    -> R (CoDomain
            (Range
             -> ModuleNameHash
             -> TopLevelModuleNameParts
             -> Bool
             -> TopLevelModuleName))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Range
    -> ModuleNameHash
    -> TopLevelModuleNameParts
    -> Bool
    -> TopLevelModuleName
    forall range.
    range
    -> ModuleNameHash
    -> TopLevelModuleNameParts
    -> Bool
    -> TopLevelModuleName' range
    TopLevelModuleName

    instance {-# OVERLAPPABLE #-} EmbPrj a => EmbPrj [a] where
      icod_ :: [a] -> S Word32
    icod_ [a]
    xs = Node -> S Word32
    icodeNode (Node -> S Word32) -> ReaderT Dict IO Node -> S Word32
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< [a] -> ReaderT Dict IO Node
    go [a]
    xs where
        go :: [a] -> S Node
        go :: [a] -> ReaderT Dict IO Node
    go []     = Node -> ReaderT Dict IO Node
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Node
    Empty
        go (a
    a:[a]
    as) = do {n <- a -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode a
    a; ns <- go as; pure $! Cons n ns}

      value :: Word32 -> R [a]
    value = ([Word32] -> R [a]) -> Word32 -> R [a]
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase ((Word32 -> StateT St IO a) -> [Word32] -> R [a]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
    mapM Word32 -> StateT St IO a
    forall a. EmbPrj a => Word32 -> R a
    value)

    instance EmbPrj a => EmbPrj (List1 a) where
      icod_ :: List1 a -> S Word32
    icod_ = [a] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icod_ ([a] -> S Word32) -> (List1 a -> [a]) -> List1 a -> S Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . List1 a -> [a]
    List1 a -> [Item (List1 a)]
    forall l. IsList l => l -> [Item l]
    List1.toList
      value :: Word32 -> R (List1 a)
    value = R (List1 a)
    -> (List1 a -> R (List1 a)) -> Maybe (List1 a) -> R (List1 a)
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe R (List1 a)
    forall a. R a
    malformed List1 a -> R (List1 a)
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (List1 a) -> R (List1 a))
    -> ([a] -> Maybe (List1 a)) -> [a] -> R (List1 a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [a] -> Maybe (List1 a)
    forall a. [a] -> Maybe (NonEmpty a)
    List1.nonEmpty ([a] -> R (List1 a))
    -> (Word32 -> StateT St IO [a]) -> Word32 -> R (List1 a)
    forall (m :: * -> *) b c a.
    Monad m =>
    (b -> m c) -> (a -> m b) -> a -> m c
    <=< Word32 -> StateT St IO [a]
    forall a. EmbPrj a => Word32 -> R a
    value

    instance EmbPrj a => EmbPrj (List2 a) where
      icod_ :: List2 a -> S Word32
    icod_ = [a] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icod_ ([a] -> S Word32) -> (List2 a -> [a]) -> List2 a -> S Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . List2 a -> [a]
    List2 a -> [Item (List2 a)]
    forall l. IsList l => l -> [Item l]
    List2.toList
      value :: Word32 -> R (List2 a)
    value = R (List2 a)
    -> (List2 a -> R (List2 a)) -> Maybe (List2 a) -> R (List2 a)
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe R (List2 a)
    forall a. R a
    malformed List2 a -> R (List2 a)
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe (List2 a) -> R (List2 a))
    -> ([a] -> Maybe (List2 a)) -> [a] -> R (List2 a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [a] -> Maybe (List2 a)
    forall a. [a] -> Maybe (List2 a)
    List2.fromListMaybe ([a] -> R (List2 a))
    -> (Word32 -> StateT St IO [a]) -> Word32 -> R (List2 a)
    forall (m :: * -> *) b c a.
    Monad m =>
    (b -> m c) -> (a -> m b) -> a -> m c
    <=< Word32 -> StateT St IO [a]
    forall a. EmbPrj a => Word32 -> R a
    value

    instance (EmbPrj k, EmbPrj v, EmbPrj (BiMap.Tag v)) =>
             EmbPrj (BiMap k v) where
      icod_ :: BiMap k v -> S Word32
    icod_ BiMap k v
    m = ([(k, v)], [(Tag v, k)]) -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (BiMap k v -> ([(k, v)], [(Tag v, k)])
    forall k v. BiMap k v -> ([(k, v)], [(Tag v, k)])
    BiMap.toDistinctAscendingLists BiMap k v
    m)
      value :: Word32 -> R (BiMap k v)
    value Word32
    m = ([(k, v)], [(Tag v, k)]) -> BiMap k v
    forall k v. ([(k, v)], [(Tag v, k)]) -> BiMap k v
    BiMap.fromDistinctAscendingLists (([(k, v)], [(Tag v, k)]) -> BiMap k v)
    -> StateT St IO ([(k, v)], [(Tag v, k)]) -> R (BiMap k v)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO ([(k, v)], [(Tag v, k)])
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    m

    -- | Encode a list of key-value pairs as a flat list.
    mapPairsIcode :: (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
    mapPairsIcode :: forall k v. (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
    mapPairsIcode [(k, v)]
    xs = Node -> S Word32
    icodeNode (Node -> S Word32) -> ReaderT Dict IO Node -> S Word32
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Node -> [(k, v)] -> ReaderT Dict IO Node
    forall {a} {a}.
    (EmbPrj a, EmbPrj a) =>
    Node -> [(a, a)] -> ReaderT Dict IO Node
    convert Node
    Empty [(k, v)]
    xs where
      -- As we need to call `convert' in the tail position, the resulting list is
      -- written (and read) in reverse order, with the highest pair first in the
      -- resulting list.
      convert :: Node -> [(a, a)] -> ReaderT Dict IO Node
    convert !Node
    ys [] = Node -> ReaderT Dict IO Node
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Node
    ys
      convert  Node
    ys ((a
    start, a
    entry):[(a, a)]
    xs) = do
        start <- a -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode a
    start
        entry <- icode entry
        convert (Cons start (Cons entry ys)) xs

    mapPairsValue :: (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
    mapPairsValue :: forall k v. (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
    mapPairsValue = [(k, v)] -> [Word32] -> StateT St IO [(k, v)]
    forall {a} {b}.
    (EmbPrj a, EmbPrj b) =>
    [(a, b)] -> [Word32] -> StateT St IO [(a, b)]
    convert [] where
      convert :: [(a, b)] -> [Word32] -> StateT St IO [(a, b)]
    convert [(a, b)]
    ys [] = [(a, b)] -> StateT St IO [(a, b)]
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [(a, b)]
    ys
      convert [(a, b)]
    ys (Word32
    start:Word32
    entry:[Word32]
    xs) = do
        !start <- Word32 -> R a
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    start
        !entry <- value entry
        convert ((start, entry):ys) xs
      convert [(a, b)]
    _ [Word32]
    _ = StateT St IO [(a, b)]
    forall a. R a
    malformed

    instance (Ord a, EmbPrj a, EmbPrj b) => EmbPrj (Map a b) where
      icod_ :: Map a b -> S Word32
    icod_ Map a b
    m = [(a, b)] -> S Word32
    forall k v. (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
    mapPairsIcode (Map a b -> [(a, b)]
    forall k a. Map k a -> [(k, a)]
    Map.toAscList Map a b
    m)
      value :: Word32 -> R (Map a b)
    value = ([Word32] -> R (Map a b)) -> Word32 -> R (Map a b)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([(a, b)] -> Map a b
    forall k a. [(k, a)] -> Map k a
    Map.fromDistinctAscList ([(a, b)] -> Map a b) -> StateT St IO [(a, b)] -> R (Map a b)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!>) (StateT St IO [(a, b)] -> R (Map a b))
    -> ([Word32] -> StateT St IO [(a, b)]) -> [Word32] -> R (Map a b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Word32] -> StateT St IO [(a, b)]
    forall k v. (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
    mapPairsValue)

    instance (Ord a, EmbPrj a) => EmbPrj (Set a) where
      icod_ :: Set a -> S Word32
    icod_ Set a
    s = [a] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (Set a -> [a]
    forall a. Set a -> [a]
    Set.toAscList Set a
    s)
      value :: Word32 -> R (Set a)
    value Word32
    s = [a] -> Set a
    forall a. [a] -> Set a
    Set.fromDistinctAscList ([a] -> Set a) -> StateT St IO [a] -> R (Set a)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO [a]
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    s

    instance (Ord a, EmbPrj a) => EmbPrj (Set1 a) where
      icod_ :: Set1 a -> S Word32
    icod_ Set1 a
    s = NonEmpty a -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (Set1 a -> NonEmpty a
    forall a. NESet a -> NonEmpty a
    Set1.toAscList Set1 a
    s)
      value :: Word32 -> R (Set1 a)
    value Word32
    s = NonEmpty a -> Set1 a
    forall a. NonEmpty a -> NESet a
    Set1.fromDistinctAscList (NonEmpty a -> Set1 a) -> StateT St IO (NonEmpty a) -> R (Set1 a)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO (NonEmpty a)
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    s

    instance EmbPrj IntSet where
      icod_ :: IntSet -> S Word32
    icod_ IntSet
    s = [Int] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (IntSet -> [Int]
    IntSet.toAscList IntSet
    s)
      value :: Word32 -> R IntSet
    value Word32
    s = [Int] -> IntSet
    IntSet.fromDistinctAscList ([Int] -> IntSet) -> StateT St IO [Int] -> R IntSet
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO [Int]
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    s

    instance Typeable a => EmbPrj (SmallSet a) where
      icod_ :: SmallSet a -> S Word32
    icod_ (SmallSet Word64
    a) = (Word64 -> SmallSet (ZonkAny 3))
    -> Arrows (Domains (Word64 -> SmallSet (ZonkAny 3))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Word64 -> SmallSet (ZonkAny 3)
    forall a. Word64 -> SmallSet a
    SmallSet Word64
    a
      value :: Word32 -> R (SmallSet a)
    value = (Word64 -> SmallSet a)
    -> Word32 -> R (CoDomain (Word64 -> SmallSet a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Word64 -> SmallSet a
    forall a. Word64 -> SmallSet a
    SmallSet

    instance (Ord a, EmbPrj a, EmbPrj b) => EmbPrj (Trie a b) where
      icod_ :: Trie a b -> S Word32
    icod_ (Trie Maybe b
    a Map a (Trie a b)
    b)= (Maybe b -> Map a (Trie a b) -> Trie a b)
    -> Arrows
         (Domains (Maybe b -> Map a (Trie a b) -> Trie a b)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Maybe b -> Map a (Trie a b) -> Trie a b
    forall k v. Maybe v -> Map k (Trie k v) -> Trie k v
    Trie Maybe b
    a Map a (Trie a b)
    b

      value :: Word32 -> R (Trie a b)
    value = (Maybe b -> Map a (Trie a b) -> Trie a b)
    -> Word32 -> R (CoDomain (Maybe b -> Map a (Trie a b) -> Trie a b))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Maybe b -> Map a (Trie a b) -> Trie a b
    forall k v. Maybe v -> Map k (Trie k v) -> Trie k v
    Trie

    instance EmbPrj a => EmbPrj (Seq a) where
      icod_ :: Seq a -> S Word32
    icod_ Seq a
    s = [a] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (Seq a -> [a]
    forall a. Seq a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    Fold.toList Seq a
    s)
      value :: Word32 -> R (Seq a)
    value Word32
    s = [a] -> Seq a
    forall a. [a] -> Seq a
    Seq.fromList ([a] -> Seq a) -> StateT St IO [a] -> R (Seq a)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO [a]
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    s

    instance EmbPrj a => EmbPrj (P.Interval' a) where
      icod_ :: Interval' a -> S Word32
    icod_ (P.Interval a
    f PositionWithoutFile
    p PositionWithoutFile
    q) = (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a)
    -> Arrows
         (Domains
            (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    P.Interval a
    f PositionWithoutFile
    p PositionWithoutFile
    q

      value :: Word32 -> R (Interval' a)
    value = (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a)
    -> Word32
    -> R (CoDomain
            (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    forall a.
    a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
    P.Interval

    instance EmbPrj RangeFile where
      icod_ :: RangeFile -> S Word32
    icod_ (RangeFile AbsolutePath
    _ Maybe TopLevelModuleName
    Nothing)  = S Word32
    forall a. HasCallStack => a
    __IMPOSSIBLE__
      icod_ (RangeFile AbsolutePath
    _ (Just TopLevelModuleName
    a)) = TopLevelModuleName -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode TopLevelModuleName
    a

      value :: Word32 -> R RangeFile
    value Word32
    r = do
        m :: TopLevelModuleName
                <- Word32 -> R TopLevelModuleName
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    r
        mf      <- gets modFile
        incs    <- gets includes
        (r, mf) <- liftIO $ runStateT (findFile'' incs m) mf
        modify $ \St
    s -> St
    s { modFile = mf }
        case r of
          Left FindError
    err -> IO RangeFile -> R RangeFile
    forall a. IO a -> StateT St IO a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO RangeFile -> R RangeFile) -> IO RangeFile -> R RangeFile
    forall a b. (a -> b) -> a -> b
    $ ErrorCall -> IO RangeFile
    forall e a. (HasCallStack, Exception e) => e -> IO a
    E.throwIO (ErrorCall -> IO RangeFile) -> ErrorCall -> IO RangeFile
    forall a b. (a -> b) -> a -> b
    $ String -> ErrorCall
    E.ErrorCall (String -> ErrorCall) -> String -> ErrorCall
    forall a b. (a -> b) -> a -> b
    $ String
    "file not found: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ FindError -> String
    forall a. Show a => a -> String
    show FindError
    err
          Right (SourceFile FileId
    i)  -> do
            let fp :: AbsolutePath
    fp = FileDictWithBuiltins -> FileId -> AbsolutePath
    forall a. GetIdFile a => a -> FileId -> AbsolutePath
    getIdFile (ModuleToSource -> FileDictWithBuiltins
    fileDict ModuleToSource
    mf) FileId
    i
            RangeFile -> R RangeFile
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (RangeFile -> R RangeFile) -> RangeFile -> R RangeFile
    forall a b. (a -> b) -> a -> b
    $ AbsolutePath -> Maybe TopLevelModuleName -> RangeFile
    RangeFile AbsolutePath
    fp (TopLevelModuleName -> Maybe TopLevelModuleName
    forall a. a -> Maybe a
    Just TopLevelModuleName
    m)

    -- | Ranges are always deserialised as 'noRange'.

    instance EmbPrj Range where
      icod_ :: Range -> S Word32
    icod_ Range
    _ = () -> Arrows (Domains ()) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' ()
      value :: Word32 -> R Range
    value Word32
    _ = Range -> R Range
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Range
    forall a. Range' a
    noRange

    instance EmbPrj KwRange where
      icod_ :: KwRange -> S Word32
    icod_ KwRange
    _ = () -> Arrows (Domains ()) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' ()
      value :: Word32 -> R KwRange
    value Word32
    _ = KwRange -> R KwRange
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return KwRange
    forall a. Null a => a
    empty

    -- | Ranges that should be serialised properly.

    newtype SerialisedRange = SerialisedRange { SerialisedRange -> Range
    underlyingRange :: Range }

    instance EmbPrj SerialisedRange where
      icod_ :: SerialisedRange -> S Word32
    icod_ (SerialisedRange Range
    r) = (SrcFile -> [IntervalWithoutFile] -> Range)
    -> Arrows
         (Domains (SrcFile -> [IntervalWithoutFile] -> Range)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' SrcFile -> [IntervalWithoutFile] -> Range
    forall a. a -> [IntervalWithoutFile] -> Range' a
    P.intervalsToRange (Range -> SrcFile
    P.rangeFile Range
    r) (Range -> [IntervalWithoutFile]
    forall a. Range' a -> [IntervalWithoutFile]
    P.rangeIntervals Range
    r)

      value :: Word32 -> R SerialisedRange
    value Word32
    i = Range -> SerialisedRange
    SerialisedRange (Range -> SerialisedRange) -> R Range -> R SerialisedRange
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> (SrcFile -> [IntervalWithoutFile] -> Range)
    -> Word32
    -> R (CoDomain (SrcFile -> [IntervalWithoutFile] -> Range))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN SrcFile -> [IntervalWithoutFile] -> Range
    forall a. a -> [IntervalWithoutFile] -> Range' a
    P.intervalsToRange Word32
    i

    instance EmbPrj C.Name where
      icod_ :: Name -> S Word32
    icod_ (C.NoName Range
    a NameId
    b)     = Word32
    -> (Range -> NameId -> Name)
    -> Arrows (Domains (Range -> NameId -> Name)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 Range -> NameId -> Name
    C.NoName Range
    a NameId
    b
      icod_ (C.Name Range
    r NameInScope
    nis NameParts
    xs)  = Word32
    -> (Range -> NameInScope -> NameParts -> Name)
    -> Arrows
         (Domains (Range -> NameInScope -> NameParts -> Name)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Range -> NameInScope -> NameParts -> Name
    C.Name Range
    r NameInScope
    nis NameParts
    xs

      value :: Word32 -> R Name
    value = ([Word32] -> R Name) -> Word32 -> R Name
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Name
    valu where
        valu :: [Word32] -> R Name
    valu [Word32
    0, Word32
    a, Word32
    b]       = (Range -> NameId -> Name)
    -> Arrows
         (Constant Word32 (Domains (Range -> NameId -> Name)))
         (R (CoDomain (Range -> NameId -> Name)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> NameId -> Name
    C.NoName Word32
    a Word32
    b
        valu [Word32
    1, Word32
    r, Word32
    nis, Word32
    xs] = (Range -> NameInScope -> NameParts -> Name)
    -> Arrows
         (Constant
            Word32 (Domains (Range -> NameInScope -> NameParts -> Name)))
         (R (CoDomain (Range -> NameInScope -> NameParts -> Name)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> NameInScope -> NameParts -> Name
    C.Name   Word32
    r Word32
    nis Word32
    xs
        valu [Word32]
    _               = R Name
    forall a. R a
    malformed

    instance EmbPrj NamePart where
      icod_ :: NamePart -> S Word32
    icod_ NamePart
    Hole   = NamePart -> Arrows (Domains NamePart) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' NamePart
    Hole
      icod_ (Id String
    a) = (String -> NamePart)
    -> Arrows (Domains (String -> NamePart)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' String -> NamePart
    Id String
    a

      value :: Word32 -> R NamePart
    value = ([Word32] -> R NamePart) -> Word32 -> R NamePart
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R NamePart
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains NamePart)) (R (CoDomain NamePart))
    valu []  = NamePart
    -> Arrows
         (Constant Word32 (Domains NamePart)) (R (CoDomain NamePart))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN NamePart
    Hole
        valu [Word32
    a] = (String -> NamePart)
    -> Arrows
         (Constant Word32 (Domains (String -> NamePart)))
         (R (CoDomain (String -> NamePart)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN String -> NamePart
    Id Word32
    a
        valu [Word32]
    _   = R NamePart
    Arrows (Constant Word32 (Domains NamePart)) (R (CoDomain NamePart))
    forall a. R a
    malformed

    instance EmbPrj NameInScope where
      icod_ :: NameInScope -> S Word32
    icod_ NameInScope
    InScope    = NameInScope -> Arrows (Domains NameInScope) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' NameInScope
    InScope
      icod_ NameInScope
    NotInScope = Word32 -> NameInScope -> Arrows (Domains NameInScope) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 NameInScope
    NotInScope

      value :: Word32 -> R NameInScope
    value = ([Word32] -> R NameInScope) -> Word32 -> R NameInScope
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R NameInScope
    forall {a}. (Eq a, Num a) => [a] -> R NameInScope
    valu where
        valu :: [a]
    -> Arrows
         (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
    valu []  = NameInScope
    -> Arrows
         (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN NameInScope
    InScope
        valu [a
    0] = NameInScope
    -> Arrows
         (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN NameInScope
    NotInScope
        valu [a]
    _   = R NameInScope
    Arrows
      (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
    forall a. R a
    malformed

    instance EmbPrj C.QName where
      icod_ :: QName -> S Word32
    icod_ (Qual    Name
    a QName
    b) = (Name -> QName -> QName)
    -> Arrows (Domains (Name -> QName -> QName)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Name -> QName -> QName
    Qual Name
    a QName
    b
      icod_ (C.QName Name
    a  ) = (Name -> QName) -> Arrows (Domains (Name -> QName)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Name -> QName
    C.QName Name
    a

      value :: Word32 -> R QName
    value = ([Word32] -> R QName) -> Word32 -> R QName
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R QName
    valu where
        valu :: [Word32] -> R QName
    valu [Word32
    a, Word32
    b] = (Name -> QName -> QName)
    -> Arrows
         (Constant Word32 (Domains (Name -> QName -> QName)))
         (R (CoDomain (Name -> QName -> QName)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Name -> QName -> QName
    Qual    Word32
    a Word32
    b
        valu [Word32
    a]    = (Name -> QName)
    -> Arrows
         (Constant Word32 (Domains (Name -> QName)))
         (R (CoDomain (Name -> QName)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Name -> QName
    C.QName Word32
    a
        valu [Word32]
    _      = R QName
    forall a. R a
    malformed

    instance (EmbPrj a, EmbPrj b) => EmbPrj (ImportedName' a b) where
      icod_ :: ImportedName' a b -> S Word32
    icod_ (ImportedModule b
    a) = Word32
    -> (b -> ImportedName' (ZonkAny 1) b)
    -> Arrows (Domains (b -> ImportedName' (ZonkAny 1) b)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 b -> ImportedName' (ZonkAny 1) b
    forall n m. m -> ImportedName' n m
    ImportedModule b
    a
      icod_ (ImportedName a
    a)   = Word32
    -> (a -> ImportedName' a (ZonkAny 2))
    -> Arrows (Domains (a -> ImportedName' a (ZonkAny 2))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    2 a -> ImportedName' a (ZonkAny 2)
    forall n m. n -> ImportedName' n m
    ImportedName a
    a

      value :: Word32 -> R (ImportedName' a b)
    value = ([Word32] -> R (ImportedName' a b))
    -> Word32 -> R (ImportedName' a b)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R (ImportedName' a b)
    forall {m} {n}.
    (EmbPrj m, EmbPrj n) =>
    [Word32] -> R (ImportedName' n m)
    valu where
        valu :: [Word32] -> R (ImportedName' n m)
    valu [Word32
    1, Word32
    a] = (m -> ImportedName' n m)
    -> Arrows
         (Constant Word32 (Domains (m -> ImportedName' n m)))
         (R (CoDomain (m -> ImportedName' n m)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN m -> ImportedName' n m
    forall n m. m -> ImportedName' n m
    ImportedModule Word32
    a
        valu [Word32
    2, Word32
    a] = (n -> ImportedName' n m)
    -> Arrows
         (Constant Word32 (Domains (n -> ImportedName' n m)))
         (R (CoDomain (n -> ImportedName' n m)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN n -> ImportedName' n m
    forall n m. n -> ImportedName' n m
    ImportedName Word32
    a
        valu [Word32]
    _ = R (ImportedName' n m)
    forall a. R a
    malformed

    instance EmbPrj Associativity where
      icod_ :: Associativity -> S Word32
    icod_ Associativity
    LeftAssoc  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    0
      icod_ Associativity
    RightAssoc = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    1
      icod_ Associativity
    NonAssoc   = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    2

      value :: Word32 -> R Associativity
    value = \case
        Word32
    0 -> Associativity -> R Associativity
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Associativity
    LeftAssoc
        Word32
    1 -> Associativity -> R Associativity
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Associativity
    RightAssoc
        Word32
    2 -> Associativity -> R Associativity
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Associativity
    NonAssoc
        Word32
    _ -> R Associativity
    forall a. R a
    malformed

    instance EmbPrj FixityLevel where
      icod_ :: FixityLevel -> S Word32
    icod_ FixityLevel
    Unrelated   = FixityLevel -> Arrows (Domains FixityLevel) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' FixityLevel
    Unrelated
      icod_ (Related Double
    a) = (Double -> FixityLevel)
    -> Arrows (Domains (Double -> FixityLevel)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Double -> FixityLevel
    Related Double
    a

      value :: Word32 -> R FixityLevel
    value = ([Word32] -> R FixityLevel) -> Word32 -> R FixityLevel
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R FixityLevel
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains FixityLevel)) (R (CoDomain FixityLevel))
    valu []  = FixityLevel
    -> Arrows
         (Constant Word32 (Domains FixityLevel)) (R (CoDomain FixityLevel))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN FixityLevel
    Unrelated
        valu [Word32
    a] = (Double -> FixityLevel)
    -> Arrows
         (Constant Word32 (Domains (Double -> FixityLevel)))
         (R (CoDomain (Double -> FixityLevel)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Double -> FixityLevel
    Related Word32
    a
        valu [Word32]
    _   = R FixityLevel
    Arrows
      (Constant Word32 (Domains FixityLevel)) (R (CoDomain FixityLevel))
    forall a. R a
    malformed

    instance EmbPrj Fixity where
      icod_ :: Fixity -> S Word32
    icod_ (Fixity Range
    a FixityLevel
    b Associativity
    c) = (Range -> FixityLevel -> Associativity -> Fixity)
    -> Arrows
         (Domains (Range -> FixityLevel -> Associativity -> Fixity))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Range -> FixityLevel -> Associativity -> Fixity
    Fixity Range
    a FixityLevel
    b Associativity
    c

      value :: Word32 -> R Fixity
    value = (Range -> FixityLevel -> Associativity -> Fixity)
    -> Word32
    -> R (CoDomain (Range -> FixityLevel -> Associativity -> Fixity))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Range -> FixityLevel -> Associativity -> Fixity
    Fixity

    instance EmbPrj Fixity' where
      icod_ :: Fixity' -> S Word32
    icod_ (Fixity' Fixity
    a Notation
    b Range
    r) = (Fixity -> Notation -> Fixity')
    -> Arrows (Domains (Fixity -> Notation -> Fixity')) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' (\ Fixity
    a Notation
    b -> Fixity -> Notation -> Range -> Fixity'
    Fixity' Fixity
    a Notation
    b Range
    r) Fixity
    a Notation
    b  -- discard theNameRange

      value :: Word32 -> R Fixity'
    value = (Fixity -> Notation -> Fixity')
    -> Word32 -> R (CoDomain (Fixity -> Notation -> Fixity'))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN (\ Fixity
    f Notation
    n -> Fixity -> Notation -> Range -> Fixity'
    Fixity' Fixity
    f Notation
    n Range
    forall a. Range' a
    noRange)

    instance EmbPrj BoundVariablePosition where
      icod_ :: BoundVariablePosition -> S Word32
    icod_ (BoundVariablePosition Int
    a Int
    b) = (Int -> Int -> BoundVariablePosition)
    -> Arrows
         (Domains (Int -> Int -> BoundVariablePosition)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Int -> Int -> BoundVariablePosition
    BoundVariablePosition Int
    a Int
    b

      value :: Word32 -> R BoundVariablePosition
    value = (Int -> Int -> BoundVariablePosition)
    -> Word32 -> R (CoDomain (Int -> Int -> BoundVariablePosition))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Int -> Int -> BoundVariablePosition
    BoundVariablePosition

    instance EmbPrj NotationPart where
      icod_ :: NotationPart -> S Word32
    icod_ (VarPart Range
    a Ranged BoundVariablePosition
    b)  = Word32
    -> (Range -> Ranged BoundVariablePosition -> NotationPart)
    -> Arrows
         (Domains (Range -> Ranged BoundVariablePosition -> NotationPart))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 Range -> Ranged BoundVariablePosition -> NotationPart
    VarPart Range
    a Ranged BoundVariablePosition
    b
      icod_ (HolePart Range
    a NamedArg (Ranged Int)
    b) = Word32
    -> (Range -> NamedArg (Ranged Int) -> NotationPart)
    -> Arrows
         (Domains (Range -> NamedArg (Ranged Int) -> NotationPart))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Range -> NamedArg (Ranged Int) -> NotationPart
    HolePart Range
    a NamedArg (Ranged Int)
    b
      icod_ (WildPart Ranged BoundVariablePosition
    a)   = Word32
    -> (Ranged BoundVariablePosition -> NotationPart)
    -> Arrows
         (Domains (Ranged BoundVariablePosition -> NotationPart)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    2 Ranged BoundVariablePosition -> NotationPart
    WildPart Ranged BoundVariablePosition
    a
      icod_ (IdPart RString
    a)     = (RString -> NotationPart)
    -> Arrows (Domains (RString -> NotationPart)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' RString -> NotationPart
    IdPart RString
    a

      value :: Word32 -> R NotationPart
    value = ([Word32] -> R NotationPart) -> Word32 -> R NotationPart
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R NotationPart
    valu where
        valu :: [Word32] -> R NotationPart
    valu [Word32
    0, Word32
    a, Word32
    b] = (Range -> Ranged BoundVariablePosition -> NotationPart)
    -> Arrows
         (Constant
            Word32
            (Domains (Range -> Ranged BoundVariablePosition -> NotationPart)))
         (R (CoDomain
               (Range -> Ranged BoundVariablePosition -> NotationPart)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> Ranged BoundVariablePosition -> NotationPart
    VarPart Word32
    a Word32
    b
        valu [Word32
    1, Word32
    a, Word32
    b] = (Range -> NamedArg (Ranged Int) -> NotationPart)
    -> Arrows
         (Constant
            Word32 (Domains (Range -> NamedArg (Ranged Int) -> NotationPart)))
         (R (CoDomain (Range -> NamedArg (Ranged Int) -> NotationPart)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> NamedArg (Ranged Int) -> NotationPart
    HolePart Word32
    a Word32
    b
        valu [Word32
    2, Word32
    a]    = (Ranged BoundVariablePosition -> NotationPart)
    -> Arrows
         (Constant
            Word32 (Domains (Ranged BoundVariablePosition -> NotationPart)))
         (R (CoDomain (Ranged BoundVariablePosition -> NotationPart)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Ranged BoundVariablePosition -> NotationPart
    WildPart Word32
    a
        valu [Word32
    a]       = (RString -> NotationPart)
    -> Arrows
         (Constant Word32 (Domains (RString -> NotationPart)))
         (R (CoDomain (RString -> NotationPart)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN RString -> NotationPart
    IdPart Word32
    a
        valu [Word32]
    _         = R NotationPart
    forall a. R a
    malformed

    instance EmbPrj MetaId where
      icod_ :: MetaId -> S Word32
    icod_ (MetaId Word64
    a ModuleNameHash
    b) = (Word64, ModuleNameHash) -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode (Word64
    a, ModuleNameHash
    b)

      value :: Word32 -> R MetaId
    value Word32
    m = (Word64 -> ModuleNameHash -> MetaId)
    -> (Word64, ModuleNameHash) -> MetaId
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Word64 -> ModuleNameHash -> MetaId
    MetaId ((Word64, ModuleNameHash) -> MetaId)
    -> StateT St IO (Word64, ModuleNameHash) -> R MetaId
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO (Word64, ModuleNameHash)
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    m

    instance EmbPrj ProblemId where
      icod_ :: ProblemId -> S Word32
    icod_ (ProblemId Int
    a) = Int -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode Int
    a

      value :: Word32 -> R ProblemId
    value Word32
    m = Int -> ProblemId
    ProblemId (Int -> ProblemId) -> R Int -> R ProblemId
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> R Int
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    m

    instance EmbPrj A.QName where
      icod_ :: QName -> S Word32
    icod_ n :: QName
    n@(A.QName ModuleName
    a Name
    b) = (Dict -> HashTable QNameId Word32)
    -> (Dict -> IORef FreshAndReuse) -> QNameId -> S Word32 -> S Word32
    forall a.
    (Ord a, Hashable a) =>
    (Dict -> HashTable a Word32)
    -> (Dict -> IORef FreshAndReuse) -> a -> S Word32 -> S Word32
    icodeMemo Dict -> HashTable QNameId Word32
    qnameD Dict -> IORef FreshAndReuse
    qnameC (QName -> QNameId
    qnameId QName
    n) (S Word32 -> S Word32) -> S Word32 -> S Word32
    forall a b. (a -> b) -> a -> b
    $ (ModuleName -> Name -> QName)
    -> Arrows (Domains (ModuleName -> Name -> QName)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' ModuleName -> Name -> QName
    A.QName ModuleName
    a Name
    b

      value :: Word32 -> R QName
    value = (ModuleName -> Name -> QName)
    -> Word32 -> R (CoDomain (ModuleName -> Name -> QName))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN ModuleName -> Name -> QName
    A.QName

    instance EmbPrj A.AmbiguousQName where
      icod_ :: AmbiguousQName -> S Word32
    icod_ (A.AmbQ List1 QName
    a) = List1 QName -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode List1 QName
    a
      value :: Word32 -> R AmbiguousQName
    value Word32
    n          = List1 QName -> AmbiguousQName
    A.AmbQ (List1 QName -> AmbiguousQName)
    -> StateT St IO (List1 QName) -> R AmbiguousQName
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO (List1 QName)
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    n

    instance EmbPrj A.ModuleName where
      icod_ :: ModuleName -> S Word32
    icod_ (A.MName [Name]
    a) = [Name] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode [Name]
    a
      value :: Word32 -> R ModuleName
    value Word32
    n           = [Name] -> ModuleName
    A.MName ([Name] -> ModuleName) -> StateT St IO [Name] -> R ModuleName
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO [Name]
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    n

    instance EmbPrj A.Name where
      icod_ :: Name -> S Word32
    icod_ (A.Name NameId
    a Name
    b Name
    c Range
    d Fixity'
    e Bool
    f) = (Dict -> HashTable NameId Word32)
    -> (Dict -> IORef FreshAndReuse) -> NameId -> S Word32 -> S Word32
    forall a.
    (Ord a, Hashable a) =>
    (Dict -> HashTable a Word32)
    -> (Dict -> IORef FreshAndReuse) -> a -> S Word32 -> S Word32
    icodeMemo Dict -> HashTable NameId Word32
    nameD Dict -> IORef FreshAndReuse
    nameC NameId
    a (S Word32 -> S Word32) -> S Word32 -> S Word32
    forall a b. (a -> b) -> a -> b
    $
        (NameId
     -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name)
    -> Arrows
         (Domains
            (NameId
             -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' (\ NameId
    a Name
    b Name
    c -> NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
    A.Name NameId
    a Name
    b Name
    c (Range -> Fixity' -> Bool -> Name)
    -> (SerialisedRange -> Range)
    -> SerialisedRange
    -> Fixity'
    -> Bool
    -> Name
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . SerialisedRange -> Range
    underlyingRange) NameId
    a Name
    b Name
    c (Range -> SerialisedRange
    SerialisedRange Range
    d) Fixity'
    e Bool
    f

      value :: Word32 -> R Name
    value = (NameId
     -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name)
    -> Word32
    -> R (CoDomain
            (NameId
             -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN (\NameId
    a Name
    b Name
    c SerialisedRange
    d -> NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
    A.Name NameId
    a Name
    b Name
    c (SerialisedRange -> Range
    underlyingRange SerialisedRange
    d))

    instance EmbPrj a => EmbPrj (C.FieldAssignment' a) where
      icod_ :: FieldAssignment' a -> S Word32
    icod_ (C.FieldAssignment Name
    a a
    b) = (Name -> a -> FieldAssignment' a)
    -> Arrows (Domains (Name -> a -> FieldAssignment' a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Name -> a -> FieldAssignment' a
    forall a. Name -> a -> FieldAssignment' a
    C.FieldAssignment Name
    a a
    b

      value :: Word32 -> R (FieldAssignment' a)
    value = (Name -> a -> FieldAssignment' a)
    -> Word32 -> R (CoDomain (Name -> a -> FieldAssignment' a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Name -> a -> FieldAssignment' a
    forall a. Name -> a -> FieldAssignment' a
    C.FieldAssignment

    instance (EmbPrj s, EmbPrj t) => EmbPrj (Named s t) where
      icod_ :: Named s t -> S Word32
    icod_ (Named Maybe s
    a t
    b) = (Maybe s -> t -> Named s t)
    -> Arrows (Domains (Maybe s -> t -> Named s t)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Maybe s -> t -> Named s t
    forall name a. Maybe name -> a -> Named name a
    Named Maybe s
    a t
    b

      value :: Word32 -> R (Named s t)
    value = (Maybe s -> t -> Named s t)
    -> Word32 -> R (CoDomain (Maybe s -> t -> Named s t))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Maybe s -> t -> Named s t
    forall name a. Maybe name -> a -> Named name a
    Named

    instance EmbPrj a => EmbPrj (Ranged a) where
      icod_ :: Ranged a -> S Word32
    icod_ (Ranged Range
    r a
    x) = (Range -> a -> Ranged a)
    -> Arrows (Domains (Range -> a -> Ranged a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Range -> a -> Ranged a
    forall a. Range -> a -> Ranged a
    Ranged Range
    r a
    x

      value :: Word32 -> R (Ranged a)
    value = (Range -> a -> Ranged a)
    -> Word32 -> R (CoDomain (Range -> a -> Ranged a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Range -> a -> Ranged a
    forall a. Range -> a -> Ranged a
    Ranged

    instance EmbPrj ArgInfo where
      icod_ :: ArgInfo -> S Word32
    icod_ (ArgInfo Hiding
    h Modality
    r Origin
    o FreeVariables
    fv Annotation
    ann) = (Hiding
     -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo)
    -> Arrows
         (Domains
            (Hiding
             -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Hiding
    -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo
    ArgInfo Hiding
    h Modality
    r Origin
    o FreeVariables
    fv Annotation
    ann

      value :: Word32 -> R ArgInfo
    value = (Hiding
     -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo)
    -> Word32
    -> R (CoDomain
            (Hiding
             -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Hiding
    -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo
    ArgInfo

    instance EmbPrj ModuleNameHash where
      icod_ :: ModuleNameHash -> S Word32
    icod_ (ModuleNameHash Word64
    a) = (Word64 -> ModuleNameHash)
    -> Arrows (Domains (Word64 -> ModuleNameHash)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Word64 -> ModuleNameHash
    ModuleNameHash Word64
    a

      value :: Word32 -> R ModuleNameHash
    value = (Word64 -> ModuleNameHash)
    -> Word32 -> R (CoDomain (Word64 -> ModuleNameHash))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Word64 -> ModuleNameHash
    ModuleNameHash

    instance EmbPrj NameId where
      icod_ :: NameId -> S Word32
    icod_ (NameId Word64
    a ModuleNameHash
    b) = (Word64 -> ModuleNameHash -> NameId)
    -> Arrows (Domains (Word64 -> ModuleNameHash -> NameId)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Word64 -> ModuleNameHash -> NameId
    NameId Word64
    a ModuleNameHash
    b

      value :: Word32 -> R NameId
    value = (Word64 -> ModuleNameHash -> NameId)
    -> Word32 -> R (CoDomain (Word64 -> ModuleNameHash -> NameId))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Word64 -> ModuleNameHash -> NameId
    NameId

    instance EmbPrj OpaqueId where
      icod_ :: OpaqueId -> S Word32
    icod_ (OpaqueId Word64
    a ModuleNameHash
    b) = (Word64 -> ModuleNameHash -> OpaqueId)
    -> Arrows
         (Domains (Word64 -> ModuleNameHash -> OpaqueId)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Word64 -> ModuleNameHash -> OpaqueId
    OpaqueId Word64
    a ModuleNameHash
    b

      value :: Word32 -> R OpaqueId
    value = (Word64 -> ModuleNameHash -> OpaqueId)
    -> Word32 -> R (CoDomain (Word64 -> ModuleNameHash -> OpaqueId))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Word64 -> ModuleNameHash -> OpaqueId
    OpaqueId

    instance (Eq k, Hashable k, EmbPrj k, EmbPrj v) => EmbPrj (HashMap k v) where
      icod_ :: HashMap k v -> S Word32
    icod_ HashMap k v
    m = [(k, v)] -> S Word32
    forall k v. (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
    mapPairsIcode (HashMap k v -> [(k, v)]
    forall k v. HashMap k v -> [(k, v)]
    HMap.toList HashMap k v
    m)
      value :: Word32 -> R (HashMap k v)
    value = ([Word32] -> R (HashMap k v)) -> Word32 -> R (HashMap k v)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([(k, v)] -> HashMap k v
    forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
    HMap.fromList ([(k, v)] -> HashMap k v)
    -> StateT St IO [(k, v)] -> R (HashMap k v)
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!>) (StateT St IO [(k, v)] -> R (HashMap k v))
    -> ([Word32] -> StateT St IO [(k, v)])
    -> [Word32]
    -> R (HashMap k v)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Word32] -> StateT St IO [(k, v)]
    forall k v. (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
    mapPairsValue)

    instance EmbPrj a => EmbPrj (WithHiding a) where
      icod_ :: WithHiding a -> S Word32
    icod_ (WithHiding Hiding
    a a
    b) = (Hiding -> a -> WithHiding a)
    -> Arrows (Domains (Hiding -> a -> WithHiding a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Hiding -> a -> WithHiding a
    forall a. Hiding -> a -> WithHiding a
    WithHiding Hiding
    a a
    b

      value :: Word32 -> R (WithHiding a)
    value = (Hiding -> a -> WithHiding a)
    -> Word32 -> R (CoDomain (Hiding -> a -> WithHiding a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Hiding -> a -> WithHiding a
    forall a. Hiding -> a -> WithHiding a
    WithHiding

    instance EmbPrj a => EmbPrj (Arg a) where
      icod_ :: Arg a -> S Word32
    icod_ (Arg ArgInfo
    i a
    e) = (ArgInfo -> a -> Arg a)
    -> Arrows (Domains (ArgInfo -> a -> Arg a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' ArgInfo -> a -> Arg a
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    i a
    e

      value :: Word32 -> R (Arg a)
    value = (ArgInfo -> a -> Arg a)
    -> Word32 -> R (CoDomain (ArgInfo -> a -> Arg a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN ArgInfo -> a -> Arg a
    forall e. ArgInfo -> e -> Arg e
    Arg

    instance EmbPrj a => EmbPrj (HasEta' a) where
      icod_ :: HasEta' a -> S Word32
    icod_ HasEta' a
    YesEta    = HasEta' (ZonkAny 0)
    -> Arrows (Domains (HasEta' (ZonkAny 0))) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' HasEta' (ZonkAny 0)
    forall a. HasEta' a
    YesEta
      icod_ (NoEta a
    a) = (a -> HasEta' a) -> Arrows (Domains (a -> HasEta' a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' a -> HasEta' a
    forall a. a -> HasEta' a
    NoEta a
    a

      value :: Word32 -> R (HasEta' a)
    value = ([Word32] -> R (HasEta' a)) -> Word32 -> R (HasEta' a)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R (HasEta' a)
    forall {a}. EmbPrj a => [Word32] -> StateT St IO (HasEta' a)
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains (HasEta' a))) (R (CoDomain (HasEta' a)))
    valu []  = HasEta' a
    -> Arrows
         (Constant Word32 (Domains (HasEta' a))) (R (CoDomain (HasEta' a)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN HasEta' a
    forall a. HasEta' a
    YesEta
        valu [Word32
    a] = (a -> HasEta' a)
    -> Arrows
         (Constant Word32 (Domains (a -> HasEta' a)))
         (R (CoDomain (a -> HasEta' a)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN a -> HasEta' a
    forall a. a -> HasEta' a
    NoEta Word32
    a
        valu [Word32]
    _   = StateT St IO (HasEta' a)
    Arrows
      (Constant Word32 (Domains (HasEta' a))) (R (CoDomain (HasEta' a)))
    forall a. R a
    malformed

    instance EmbPrj PatternOrCopattern
    instance EmbPrj OverlapMode

    instance EmbPrj Induction where
      icod_ :: Induction -> S Word32
    icod_ Induction
    Inductive   = Induction -> Arrows (Domains Induction) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Induction
    Inductive
      icod_ Induction
    CoInductive = Word32 -> Induction -> Arrows (Domains Induction) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Induction
    CoInductive

      value :: Word32 -> R Induction
    value = ([Word32] -> R Induction) -> Word32 -> R Induction
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Induction
    forall {a}. (Eq a, Num a) => [a] -> R Induction
    valu where
        valu :: [a]
    -> Arrows
         (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
    valu []  = Induction
    -> Arrows
         (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Induction
    Inductive
        valu [a
    1] = Induction
    -> Arrows
         (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Induction
    CoInductive
        valu [a]
    _   = R Induction
    Arrows
      (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
    forall a. R a
    malformed

    instance EmbPrj Hiding where
      icod_ :: Hiding -> S Word32
    icod_ Hiding
    Hidden                = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
      icod_ Hiding
    NotHidden             = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
      icod_ (Instance Overlappable
    NoOverlap)  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2
      icod_ (Instance Overlappable
    YesOverlap) = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    3

      value :: Word32 -> R Hiding
    value Word32
    0 = Hiding -> R Hiding
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Hiding
    Hidden
      value Word32
    1 = Hiding -> R Hiding
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Hiding
    NotHidden
      value Word32
    2 = Hiding -> R Hiding
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Overlappable -> Hiding
    Instance Overlappable
    NoOverlap)
      value Word32
    3 = Hiding -> R Hiding
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Overlappable -> Hiding
    Instance Overlappable
    YesOverlap)
      value Word32
    _ = R Hiding
    forall a. R a
    malformed

    instance EmbPrj Q0Origin where
      icod_ :: Q0Origin -> S Word32
    icod_ = \case
        Q0Origin
    Q0Inferred -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
        Q0 Range
    _       -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
        Q0Erased Range
    _ -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2

      value :: Word32 -> R Q0Origin
    value = \case
        Word32
    0 -> Q0Origin -> R Q0Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Q0Origin -> R Q0Origin) -> Q0Origin -> R Q0Origin
    forall a b. (a -> b) -> a -> b
    $ Q0Origin
    Q0Inferred
        Word32
    1 -> Q0Origin -> R Q0Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Q0Origin -> R Q0Origin) -> Q0Origin -> R Q0Origin
    forall a b. (a -> b) -> a -> b
    $ Range -> Q0Origin
    Q0       Range
    forall a. Range' a
    noRange
        Word32
    2 -> Q0Origin -> R Q0Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Q0Origin -> R Q0Origin) -> Q0Origin -> R Q0Origin
    forall a b. (a -> b) -> a -> b
    $ Range -> Q0Origin
    Q0Erased Range
    forall a. Range' a
    noRange
        Word32
    _ -> R Q0Origin
    forall a. R a
    malformed

    instance EmbPrj Q1Origin where
      icod_ :: Q1Origin -> S Word32
    icod_ = \case
        Q1Origin
    Q1Inferred -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
        Q1 Range
    _       -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
        Q1Linear Range
    _ -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2

      value :: Word32 -> R Q1Origin
    value = \case
        Word32
    0 -> Q1Origin -> R Q1Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Q1Origin -> R Q1Origin) -> Q1Origin -> R Q1Origin
    forall a b. (a -> b) -> a -> b
    $ Q1Origin
    Q1Inferred
        Word32
    1 -> Q1Origin -> R Q1Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Q1Origin -> R Q1Origin) -> Q1Origin -> R Q1Origin
    forall a b. (a -> b) -> a -> b
    $ Range -> Q1Origin
    Q1       Range
    forall a. Range' a
    noRange
        Word32
    2 -> Q1Origin -> R Q1Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Q1Origin -> R Q1Origin) -> Q1Origin -> R Q1Origin
    forall a b. (a -> b) -> a -> b
    $ Range -> Q1Origin
    Q1Linear Range
    forall a. Range' a
    noRange
        Word32
    _ -> R Q1Origin
    forall a. R a
    malformed

    instance EmbPrj QωOrigin where
      icod_ :: QωOrigin -> S Word32
    icod_ = \case
        QωOrigin
    QωInferred -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
        Qω Range
    _       -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
        QωPlenty Range
    _ -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2

      value :: Word32 -> R QωOrigin
    value = \case
        Word32
    0 -> QωOrigin -> R QωOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (QωOrigin -> R QωOrigin) -> QωOrigin -> R QωOrigin
    forall a b. (a -> b) -> a -> b
    $ QωOrigin
    QωInferred
        Word32
    1 -> QωOrigin -> R QωOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (QωOrigin -> R QωOrigin) -> QωOrigin -> R QωOrigin
    forall a b. (a -> b) -> a -> b
    $ Range -> QωOrigin
    Qω       Range
    forall a. Range' a
    noRange
        Word32
    2 -> QωOrigin -> R QωOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (QωOrigin -> R QωOrigin) -> QωOrigin -> R QωOrigin
    forall a b. (a -> b) -> a -> b
    $ Range -> QωOrigin
    QωPlenty Range
    forall a. Range' a
    noRange
        Word32
    _ -> R QωOrigin
    forall a. R a
    malformed

    instance EmbPrj Quantity where
      icod_ :: Quantity -> S Word32
    icod_ = \case
        Quantity0 Q0Origin
    a -> Word32
    -> (Q0Origin -> Quantity)
    -> Arrows (Domains (Q0Origin -> Quantity)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 Q0Origin -> Quantity
    Quantity0 Q0Origin
    a
        Quantity1 Q1Origin
    a -> Word32
    -> (Q1Origin -> Quantity)
    -> Arrows (Domains (Q1Origin -> Quantity)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Q1Origin -> Quantity
    Quantity1 Q1Origin
    a
        Quantityω QωOrigin
    a -> (QωOrigin -> Quantity)
    -> Arrows (Domains (QωOrigin -> Quantity)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN'  QωOrigin -> Quantity
    Quantityω QωOrigin
    a  -- default quantity, shorter code

      value :: Word32 -> R Quantity
    value = ([Word32] -> R Quantity) -> Word32 -> R Quantity
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([Word32] -> R Quantity) -> Word32 -> R Quantity)
    -> ([Word32] -> R Quantity) -> Word32 -> R Quantity
    forall a b. (a -> b) -> a -> b
    $ \case
        [Word32
    0, Word32
    a] -> (Q0Origin -> Quantity)
    -> Arrows
         (Constant Word32 (Domains (Q0Origin -> Quantity)))
         (R (CoDomain (Q0Origin -> Quantity)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Q0Origin -> Quantity
    Quantity0 Word32
    a
        [Word32
    1, Word32
    a] -> (Q1Origin -> Quantity)
    -> Arrows
         (Constant Word32 (Domains (Q1Origin -> Quantity)))
         (R (CoDomain (Q1Origin -> Quantity)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Q1Origin -> Quantity
    Quantity1 Word32
    a
        [Word32
    a]    -> (QωOrigin -> Quantity)
    -> Arrows
         (Constant Word32 (Domains (QωOrigin -> Quantity)))
         (R (CoDomain (QωOrigin -> Quantity)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN QωOrigin -> Quantity
    Quantityω Word32
    a
        [Word32]
    _      -> R Quantity
    forall a. R a
    malformed

    -- -- ALT: forget quantity origin when serializing?
    -- instance EmbPrj Quantity where
    --   icod_ Quantity0 = return 0
    --   icod_ Quantity1 = return 1
    --   icod_ Quantityω = return 2

    --   value 0 = return Quantity0
    --   value 1 = return Quantity1
    --   value 2 = return Quantityω
    --   value _ = malformed

    instance EmbPrj Cohesion where
      icod_ :: Cohesion -> S Word32
    icod_ Cohesion
    Flat       = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
      icod_ Cohesion
    Continuous = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
      icod_ Cohesion
    Squash     = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2

      value :: Word32 -> R Cohesion
    value Word32
    0 = Cohesion -> R Cohesion
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cohesion
    Flat
      value Word32
    1 = Cohesion -> R Cohesion
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cohesion
    Continuous
      value Word32
    2 = Cohesion -> R Cohesion
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Cohesion
    Squash
      value Word32
    _ = R Cohesion
    forall a. R a
    malformed

    instance EmbPrj ModalPolarity where
      icod_ :: ModalPolarity -> S Word32
    icod_ ModalPolarity
    UnusedPolarity = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
      icod_ ModalPolarity
    StrictlyPositive = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
      icod_ ModalPolarity
    Positive = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2
      icod_ ModalPolarity
    Negative = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    3
      icod_ ModalPolarity
    MixedPolarity = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    4

      value :: Word32 -> R ModalPolarity
    value Word32
    0 = ModalPolarity -> R ModalPolarity
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ModalPolarity
    UnusedPolarity
      value Word32
    1 = ModalPolarity -> R ModalPolarity
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ModalPolarity
    StrictlyPositive
      value Word32
    2 = ModalPolarity -> R ModalPolarity
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ModalPolarity
    Positive
      value Word32
    3 = ModalPolarity -> R ModalPolarity
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ModalPolarity
    Negative
      value Word32
    4 = ModalPolarity -> R ModalPolarity
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ModalPolarity
    MixedPolarity
      value Word32
    _ = R ModalPolarity
    forall a. R a
    malformed

    instance EmbPrj PolarityModality where
      icod_ :: PolarityModality -> S Word32
    icod_ (PolarityModality ModalPolarity
    p ModalPolarity
    o ModalPolarity
    l) = (ModalPolarity, ModalPolarity, ModalPolarity) -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icod_ (ModalPolarity
    p, ModalPolarity
    o, ModalPolarity
    l)

      value :: Word32 -> R PolarityModality
    value Word32
    n = do
        (p, o, l) <- R (ModalPolarity, ModalPolarity, ModalPolarity)
    polPair
        return $ PolarityModality p o l
        where
          polPair :: R (ModalPolarity, ModalPolarity, ModalPolarity)
          polPair :: R (ModalPolarity, ModalPolarity, ModalPolarity)
    polPair = Word32 -> R (ModalPolarity, ModalPolarity, ModalPolarity)
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    n

    instance EmbPrj Modality where
      icod_ :: Modality -> S Word32
    icod_ (Modality Relevance
    a Quantity
    b Cohesion
    c PolarityModality
    d) = (Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality)
    -> Arrows
         (Domains
            (Relevance
             -> Quantity -> Cohesion -> PolarityModality -> Modality))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Relevance
    a Quantity
    b Cohesion
    c PolarityModality
    d

      value :: Word32 -> R Modality
    value = ([Word32] -> R Modality) -> Word32 -> R Modality
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase (([Word32] -> R Modality) -> Word32 -> R Modality)
    -> ([Word32] -> R Modality) -> Word32 -> R Modality
    forall a b. (a -> b) -> a -> b
    $ \case
        [Word32
    a, Word32
    b, Word32
    c, Word32
    d] -> (Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality)
    -> Arrows
         (Constant
            Word32
            (Domains
               (Relevance
                -> Quantity -> Cohesion -> PolarityModality -> Modality)))
         (R (CoDomain
               (Relevance
                -> Quantity -> Cohesion -> PolarityModality -> Modality)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
    Modality Word32
    a Word32
    b Word32
    c Word32
    d
        [Word32]
    _ -> R Modality
    forall a. R a
    malformed

    instance EmbPrj OriginRelevant where
      icod_ :: OriginRelevant -> S Word32
    icod_ = \case
        OriginRelevant
    ORelInferred   -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
        ORelRelevant Range
    _ -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1

      value :: Word32 -> R OriginRelevant
    value = \case
        Word32
    0 -> OriginRelevant -> R OriginRelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginRelevant -> R OriginRelevant)
    -> OriginRelevant -> R OriginRelevant
    forall a b. (a -> b) -> a -> b
    $ OriginRelevant
    ORelInferred
        Word32
    1 -> OriginRelevant -> R OriginRelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginRelevant -> R OriginRelevant)
    -> OriginRelevant -> R OriginRelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginRelevant
    ORelRelevant Range
    forall a. Range' a
    noRange
        Word32
    _ -> R OriginRelevant
    forall a. R a
    malformed

    instance EmbPrj OriginIrrelevant where
      icod_ :: OriginIrrelevant -> S Word32
    icod_ = \case
        OriginIrrelevant
    OIrrInferred     -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
        OIrrDot Range
    _        -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
        OIrrIrr Range
    _        -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2
        OIrrIrrelevant Range
    _ -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    3

      value :: Word32 -> R OriginIrrelevant
    value = \case
        Word32
    0 -> OriginIrrelevant -> R OriginIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginIrrelevant -> R OriginIrrelevant)
    -> OriginIrrelevant -> R OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginIrrelevant
    OIrrInferred
        Word32
    1 -> OriginIrrelevant -> R OriginIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginIrrelevant -> R OriginIrrelevant)
    -> OriginIrrelevant -> R OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginIrrelevant
    OIrrDot        Range
    forall a. Range' a
    noRange
        Word32
    2 -> OriginIrrelevant -> R OriginIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginIrrelevant -> R OriginIrrelevant)
    -> OriginIrrelevant -> R OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginIrrelevant
    OIrrIrr        Range
    forall a. Range' a
    noRange
        Word32
    3 -> OriginIrrelevant -> R OriginIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginIrrelevant -> R OriginIrrelevant)
    -> OriginIrrelevant -> R OriginIrrelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginIrrelevant
    OIrrIrrelevant Range
    forall a. Range' a
    noRange
        Word32
    _ -> R OriginIrrelevant
    forall a. R a
    malformed

    instance EmbPrj OriginShapeIrrelevant where
      icod_ :: OriginShapeIrrelevant -> S Word32
    icod_ = \case
        OriginShapeIrrelevant
    OShIrrInferred          -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
        OShIrrDotDot Range
    _          -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
        OShIrrShIrr Range
    _           -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2
        OShIrrShapeIrrelevant Range
    _ -> Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    3

      value :: Word32 -> R OriginShapeIrrelevant
    value = \case
        Word32
    0 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
    -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ OriginShapeIrrelevant
    OShIrrInferred
        Word32
    1 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
    -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginShapeIrrelevant
    OShIrrDotDot          Range
    forall a. Range' a
    noRange
        Word32
    2 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
    -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginShapeIrrelevant
    OShIrrShIrr           Range
    forall a. Range' a
    noRange
        Word32
    3 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
    -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
    forall a b. (a -> b) -> a -> b
    $ Range -> OriginShapeIrrelevant
    OShIrrShapeIrrelevant Range
    forall a. Range' a
    noRange
        Word32
    _ -> R OriginShapeIrrelevant
    forall a. R a
    malformed

    instance EmbPrj Relevance where
      icod_ :: Relevance -> S Word32
    icod_ = \case
        Relevant   OriginRelevant
    a      -> (OriginRelevant -> Relevance)
    -> Arrows (Domains (OriginRelevant -> Relevance)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' OriginRelevant -> Relevance
    Relevant OriginRelevant
    a
        Irrelevant OriginIrrelevant
    a      -> Word32
    -> (OriginIrrelevant -> Relevance)
    -> Arrows (Domains (OriginIrrelevant -> Relevance)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 OriginIrrelevant -> Relevance
    Irrelevant OriginIrrelevant
    a
        ShapeIrrelevant OriginShapeIrrelevant
    a -> Word32
    -> (OriginShapeIrrelevant -> Relevance)
    -> Arrows (Domains (OriginShapeIrrelevant -> Relevance)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 OriginShapeIrrelevant -> Relevance
    ShapeIrrelevant OriginShapeIrrelevant
    a

      value :: Word32 -> R Relevance
    value = ([Word32] -> R Relevance) -> Word32 -> R Relevance
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase \case
        [Word32
    a]    -> (OriginRelevant -> Relevance)
    -> Arrows
         (Constant Word32 (Domains (OriginRelevant -> Relevance)))
         (R (CoDomain (OriginRelevant -> Relevance)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN OriginRelevant -> Relevance
    Relevant Word32
    a
        [Word32
    0, Word32
    a] -> (OriginIrrelevant -> Relevance)
    -> Arrows
         (Constant Word32 (Domains (OriginIrrelevant -> Relevance)))
         (R (CoDomain (OriginIrrelevant -> Relevance)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN OriginIrrelevant -> Relevance
    Irrelevant Word32
    a
        [Word32
    1, Word32
    a] -> (OriginShapeIrrelevant -> Relevance)
    -> Arrows
         (Constant Word32 (Domains (OriginShapeIrrelevant -> Relevance)))
         (R (CoDomain (OriginShapeIrrelevant -> Relevance)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN OriginShapeIrrelevant -> Relevance
    ShapeIrrelevant Word32
    a
        [Word32]
    _      -> R Relevance
    forall a. R a
    malformed

    instance EmbPrj Annotation where
      icod_ :: Annotation -> S Word32
    icod_ (Annotation Lock
    l) = (Lock -> Annotation)
    -> Arrows (Domains (Lock -> Annotation)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Lock -> Annotation
    Annotation Lock
    l

      value :: Word32 -> R Annotation
    value = (Lock -> Annotation) -> Word32 -> R (CoDomain (Lock -> Annotation))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Lock -> Annotation
    Annotation

    instance EmbPrj Lock where
      icod_ :: Lock -> S Word32
    icod_ Lock
    IsNotLock          = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    0
      icod_ (IsLock LockOrigin
    LockOTick) = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    1
      icod_ (IsLock LockOrigin
    LockOLock) = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Word32
    2

      value :: Word32 -> R Lock
    value Word32
    0 = Lock -> R Lock
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Lock
    IsNotLock
      value Word32
    1 = Lock -> R Lock
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (LockOrigin -> Lock
    IsLock LockOrigin
    LockOTick)
      value Word32
    2 = Lock -> R Lock
    forall a. a -> StateT St IO a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (LockOrigin -> Lock
    IsLock LockOrigin
    LockOLock)
      value Word32
    _ = R Lock
    forall a. R a
    malformed

    instance EmbPrj Origin where
      icod_ :: Origin -> S Word32
    icod_ Origin
    UserWritten = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
      icod_ Origin
    Inserted    = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
      icod_ Origin
    Reflected   = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2
      icod_ Origin
    CaseSplit   = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    3
      icod_ Origin
    Substitution = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    4
      icod_ Origin
    ExpandedPun = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    5
      icod_ Origin
    Generalization = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    6

      value :: Word32 -> R Origin
    value Word32
    0 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    UserWritten
      value Word32
    1 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    Inserted
      value Word32
    2 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    Reflected
      value Word32
    3 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    CaseSplit
      value Word32
    4 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    Substitution
      value Word32
    5 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    ExpandedPun
      value Word32
    6 = Origin -> R Origin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Origin
    Generalization
      value Word32
    _ = R Origin
    forall a. R a
    malformed

    instance EmbPrj a => EmbPrj (WithOrigin a) where
      icod_ :: WithOrigin a -> S Word32
    icod_ (WithOrigin Origin
    a a
    b) = (Origin -> a -> WithOrigin a)
    -> Arrows (Domains (Origin -> a -> WithOrigin a)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Origin -> a -> WithOrigin a
    forall a. Origin -> a -> WithOrigin a
    WithOrigin Origin
    a a
    b

      value :: Word32 -> R (WithOrigin a)
    value = (Origin -> a -> WithOrigin a)
    -> Word32 -> R (CoDomain (Origin -> a -> WithOrigin a))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN Origin -> a -> WithOrigin a
    forall a. Origin -> a -> WithOrigin a
    WithOrigin

    instance EmbPrj FreeVariables where
      icod_ :: FreeVariables -> S Word32
    icod_ FreeVariables
    UnknownFVs   = FreeVariables -> Arrows (Domains FreeVariables) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' FreeVariables
    UnknownFVs
      icod_ (KnownFVs IntSet
    a) = (IntSet -> FreeVariables)
    -> Arrows (Domains (IntSet -> FreeVariables)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' IntSet -> FreeVariables
    KnownFVs IntSet
    a

      value :: Word32 -> R FreeVariables
    value = ([Word32] -> R FreeVariables) -> Word32 -> R FreeVariables
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R FreeVariables
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains FreeVariables))
         (R (CoDomain FreeVariables))
    valu []  = FreeVariables
    -> Arrows
         (Constant Word32 (Domains FreeVariables))
         (R (CoDomain FreeVariables))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN FreeVariables
    UnknownFVs
        valu [Word32
    a] = (IntSet -> FreeVariables)
    -> Arrows
         (Constant Word32 (Domains (IntSet -> FreeVariables)))
         (R (CoDomain (IntSet -> FreeVariables)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN IntSet -> FreeVariables
    KnownFVs Word32
    a
        valu [Word32]
    _   = R FreeVariables
    Arrows
      (Constant Word32 (Domains FreeVariables))
      (R (CoDomain FreeVariables))
    forall a. R a
    malformed

    instance EmbPrj ConOrigin where
      icod_ :: ConOrigin -> S Word32
    icod_ ConOrigin
    ConOSystem = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
      icod_ ConOrigin
    ConOCon    = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
      icod_ ConOrigin
    ConORec    = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2
      icod_ ConOrigin
    ConOSplit  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    3

      value :: Word32 -> R ConOrigin
    value Word32
    0 = ConOrigin -> R ConOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ConOrigin
    ConOSystem
      value Word32
    1 = ConOrigin -> R ConOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ConOrigin
    ConOCon
      value Word32
    2 = ConOrigin -> R ConOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ConOrigin
    ConORec
      value Word32
    3 = ConOrigin -> R ConOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ConOrigin
    ConOSplit
      value Word32
    _ = R ConOrigin
    forall a. R a
    malformed

    instance EmbPrj ProjOrigin where
      icod_ :: ProjOrigin -> S Word32
    icod_ ProjOrigin
    ProjPrefix  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    0
      icod_ ProjOrigin
    ProjPostfix = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    1
      icod_ ProjOrigin
    ProjSystem  = Word32 -> S Word32
    forall a. a -> ReaderT Dict IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Word32
    2

      value :: Word32 -> R ProjOrigin
    value Word32
    0 = ProjOrigin -> R ProjOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ProjOrigin
    ProjPrefix
      value Word32
    1 = ProjOrigin -> R ProjOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ProjOrigin
    ProjPostfix
      value Word32
    2 = ProjOrigin -> R ProjOrigin
    forall a. a -> StateT St IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return ProjOrigin
    ProjSystem
      value Word32
    _ = R ProjOrigin
    forall a. R a
    malformed

    instance EmbPrj Agda.Syntax.Literal.Literal where
      icod_ :: Literal -> S Word32
    icod_ (LitNat    Integer
    a)   = (Integer -> Literal)
    -> Arrows (Domains (Integer -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Integer -> Literal
    LitNat Integer
    a
      icod_ (LitFloat  Double
    a)   = Word32
    -> (Double -> Literal)
    -> Arrows (Domains (Double -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Double -> Literal
    LitFloat Double
    a
      icod_ (LitString Text
    a)   = Word32
    -> (Text -> Literal)
    -> Arrows (Domains (Text -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    2 Text -> Literal
    LitString Text
    a
      icod_ (LitChar   Char
    a)   = Word32
    -> (Char -> Literal)
    -> Arrows (Domains (Char -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    3 Char -> Literal
    LitChar Char
    a
      icod_ (LitQName  QName
    a)   = Word32
    -> (QName -> Literal)
    -> Arrows (Domains (QName -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    5 QName -> Literal
    LitQName QName
    a
      icod_ (LitMeta   TopLevelModuleName
    a MetaId
    b) = Word32
    -> (TopLevelModuleName -> MetaId -> Literal)
    -> Arrows
         (Domains (TopLevelModuleName -> MetaId -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    6 TopLevelModuleName -> MetaId -> Literal
    LitMeta TopLevelModuleName
    a MetaId
    b
      icod_ (LitWord64 Word64
    a)   = Word32
    -> (Word64 -> Literal)
    -> Arrows (Domains (Word64 -> Literal)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    7 Word64 -> Literal
    LitWord64 Word64
    a

      value :: Word32 -> R Literal
    value = ([Word32] -> R Literal) -> Word32 -> R Literal
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Literal
    valu where
        valu :: [Word32] -> R Literal
    valu [Word32
    a]       = (Integer -> Literal)
    -> Arrows
         (Constant Word32 (Domains (Integer -> Literal)))
         (R (CoDomain (Integer -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Integer -> Literal
    LitNat    Word32
    a
        valu [Word32
    1, Word32
    a]    = (Double -> Literal)
    -> Arrows
         (Constant Word32 (Domains (Double -> Literal)))
         (R (CoDomain (Double -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Double -> Literal
    LitFloat  Word32
    a
        valu [Word32
    2, Word32
    a]    = (Text -> Literal)
    -> Arrows
         (Constant Word32 (Domains (Text -> Literal)))
         (R (CoDomain (Text -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Text -> Literal
    LitString Word32
    a
        valu [Word32
    3, Word32
    a]    = (Char -> Literal)
    -> Arrows
         (Constant Word32 (Domains (Char -> Literal)))
         (R (CoDomain (Char -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Char -> Literal
    LitChar   Word32
    a
        valu [Word32
    5, Word32
    a]    = (QName -> Literal)
    -> Arrows
         (Constant Word32 (Domains (QName -> Literal)))
         (R (CoDomain (QName -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN QName -> Literal
    LitQName  Word32
    a
        valu [Word32
    6, Word32
    a, Word32
    b] = (TopLevelModuleName -> MetaId -> Literal)
    -> Arrows
         (Constant
            Word32 (Domains (TopLevelModuleName -> MetaId -> Literal)))
         (R (CoDomain (TopLevelModuleName -> MetaId -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN TopLevelModuleName -> MetaId -> Literal
    LitMeta   Word32
    a Word32
    b
        valu [Word32
    7, Word32
    a]    = (Word64 -> Literal)
    -> Arrows
         (Constant Word32 (Domains (Word64 -> Literal)))
         (R (CoDomain (Word64 -> Literal)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Word64 -> Literal
    LitWord64 Word32
    a
        valu [Word32]
    _            = R Literal
    forall a. R a
    malformed

    instance EmbPrj IsAbstract where
      icod_ :: IsAbstract -> S Word32
    icod_ IsAbstract
    AbstractDef = Word32 -> IsAbstract -> Arrows (Domains IsAbstract) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 IsAbstract
    AbstractDef
      icod_ IsAbstract
    ConcreteDef = IsAbstract -> Arrows (Domains IsAbstract) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' IsAbstract
    ConcreteDef

      value :: Word32 -> R IsAbstract
    value = ([Word32] -> R IsAbstract) -> Word32 -> R IsAbstract
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R IsAbstract
    forall {a}. (Eq a, Num a) => [a] -> R IsAbstract
    valu where
        valu :: [a]
    -> Arrows
         (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
    valu [a
    0] = IsAbstract
    -> Arrows
         (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN IsAbstract
    AbstractDef
        valu []  = IsAbstract
    -> Arrows
         (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN IsAbstract
    ConcreteDef
        valu [a]
    _   = R IsAbstract
    Arrows
      (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
    forall a. R a
    malformed

    instance EmbPrj IsOpaque where
      icod_ :: IsOpaque -> S Word32
    icod_ (OpaqueDef OpaqueId
    a)  = (OpaqueId -> IsOpaque)
    -> Arrows (Domains (OpaqueId -> IsOpaque)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' OpaqueId -> IsOpaque
    OpaqueDef OpaqueId
    a
      icod_ IsOpaque
    TransparentDef = IsOpaque -> Arrows (Domains IsOpaque) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' IsOpaque
    TransparentDef

      value :: Word32 -> R IsOpaque
    value = ([Word32] -> R IsOpaque) -> Word32 -> R IsOpaque
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R IsOpaque
    valu where
        valu :: [Word32] -> R IsOpaque
    valu [Word32
    a] = (OpaqueId -> IsOpaque)
    -> Arrows
         (Constant Word32 (Domains (OpaqueId -> IsOpaque)))
         (R (CoDomain (OpaqueId -> IsOpaque)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN OpaqueId -> IsOpaque
    OpaqueDef Word32
    a
        valu []  = IsOpaque
    -> Arrows
         (Constant Word32 (Domains IsOpaque)) (R (CoDomain IsOpaque))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN IsOpaque
    TransparentDef
        valu [Word32]
    _   = R IsOpaque
    forall a. R a
    malformed

    instance EmbPrj SrcLoc where
      icod_ :: SrcLoc -> S Word32
    icod_ (SrcLoc String
    p String
    m String
    f Int
    sl Int
    sc Int
    el Int
    ec) = (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc)
    -> Arrows
         (Domains
            (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc
    SrcLoc String
    p String
    m String
    f Int
    sl Int
    sc Int
    el Int
    ec
      value :: Word32 -> R SrcLoc
    value = (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc)
    -> Word32
    -> R (CoDomain
            (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc))
    forall t.
    (VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
    t -> Word32 -> R (CoDomain t)
    valueN String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc
    SrcLoc

    instance EmbPrj CallStack where
      icod_ :: CallStack -> S Word32
    icod_ = [(String, SrcLoc)] -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icode ([(String, SrcLoc)] -> S Word32)
    -> (CallStack -> [(String, SrcLoc)]) -> CallStack -> S Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . CallStack -> [(String, SrcLoc)]
    getCallStack
      value :: Word32 -> R CallStack
    value = ([(String, SrcLoc)] -> CallStack)
    -> StateT St IO [(String, SrcLoc)] -> R CallStack
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    (<$!>) [(String, SrcLoc)] -> CallStack
    fromCallSiteList (StateT St IO [(String, SrcLoc)] -> R CallStack)
    -> (Word32 -> StateT St IO [(String, SrcLoc)])
    -> Word32
    -> R CallStack
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> StateT St IO [(String, SrcLoc)]
    forall a. EmbPrj a => Word32 -> R a
    value

    instance EmbPrj Impossible where
      icod_ :: Impossible -> S Word32
    icod_ (Impossible CallStack
    a)              = Word32
    -> (CallStack -> Impossible)
    -> Arrows (Domains (CallStack -> Impossible)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 CallStack -> Impossible
    Impossible CallStack
    a
      icod_ (Unreachable CallStack
    a)             = Word32
    -> (CallStack -> Impossible)
    -> Arrows (Domains (CallStack -> Impossible)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 CallStack -> Impossible
    Unreachable CallStack
    a
      icod_ (ImpMissingDefinitions [String]
    a String
    b) = Word32
    -> ([String] -> String -> Impossible)
    -> Arrows (Domains ([String] -> String -> Impossible)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    2 [String] -> String -> Impossible
    ImpMissingDefinitions [String]
    a String
    b

      value :: Word32 -> R Impossible
    value = ([Word32] -> R Impossible) -> Word32 -> R Impossible
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Impossible
    valu where
        valu :: [Word32] -> R Impossible
    valu [Word32
    0, Word32
    a]    = (CallStack -> Impossible)
    -> Arrows
         (Constant Word32 (Domains (CallStack -> Impossible)))
         (R (CoDomain (CallStack -> Impossible)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN CallStack -> Impossible
    Impossible  Word32
    a
        valu [Word32
    1, Word32
    a]    = (CallStack -> Impossible)
    -> Arrows
         (Constant Word32 (Domains (CallStack -> Impossible)))
         (R (CoDomain (CallStack -> Impossible)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN CallStack -> Impossible
    Unreachable Word32
    a
        valu [Word32
    2, Word32
    a, Word32
    b] = ([String] -> String -> Impossible)
    -> Arrows
         (Constant Word32 (Domains ([String] -> String -> Impossible)))
         (R (CoDomain ([String] -> String -> Impossible)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN [String] -> String -> Impossible
    ImpMissingDefinitions Word32
    a Word32
    b
        valu [Word32]
    _         = R Impossible
    forall a. R a
    malformed

    instance EmbPrj ExpandedEllipsis where
      icod_ :: ExpandedEllipsis -> S Word32
    icod_ ExpandedEllipsis
    NoEllipsis = ExpandedEllipsis -> Arrows (Domains ExpandedEllipsis) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' ExpandedEllipsis
    NoEllipsis
      icod_ (ExpandedEllipsis Range
    a Int
    b) = Word32
    -> (Range -> Int -> ExpandedEllipsis)
    -> Arrows (Domains (Range -> Int -> ExpandedEllipsis)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Range -> Int -> ExpandedEllipsis
    ExpandedEllipsis Range
    a Int
    b

      value :: Word32 -> R ExpandedEllipsis
    value = ([Word32] -> R ExpandedEllipsis) -> Word32 -> R ExpandedEllipsis
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R ExpandedEllipsis
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains ExpandedEllipsis))
         (R (CoDomain ExpandedEllipsis))
    valu []      = ExpandedEllipsis
    -> Arrows
         (Constant Word32 (Domains ExpandedEllipsis))
         (R (CoDomain ExpandedEllipsis))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN ExpandedEllipsis
    NoEllipsis
        valu [Word32
    1,Word32
    a,Word32
    b] = (Range -> Int -> ExpandedEllipsis)
    -> Arrows
         (Constant Word32 (Domains (Range -> Int -> ExpandedEllipsis)))
         (R (CoDomain (Range -> Int -> ExpandedEllipsis)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> Int -> ExpandedEllipsis
    ExpandedEllipsis Word32
    a Word32
    b
        valu [Word32]
    _       = R ExpandedEllipsis
    Arrows
      (Constant Word32 (Domains ExpandedEllipsis))
      (R (CoDomain ExpandedEllipsis))
    forall a. R a
    malformed

    instance EmbPrj OptionsPragma where
      icod_ :: OptionsPragma -> S Word32
    icod_ (OptionsPragma [String]
    a Range
    b) = ([String], Range) -> S Word32
    forall a. EmbPrj a => a -> S Word32
    icod_ ([String]
    a, Range
    b)

      value :: Word32 -> R OptionsPragma
    value Word32
    op = ([String] -> Range -> OptionsPragma)
    -> ([String], Range) -> OptionsPragma
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry [String] -> Range -> OptionsPragma
    OptionsPragma (([String], Range) -> OptionsPragma)
    -> StateT St IO ([String], Range) -> R OptionsPragma
    forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
    <$!> Word32 -> StateT St IO ([String], Range)
    forall a. EmbPrj a => Word32 -> R a
    value Word32
    op

    instance EmbPrj BuiltinId
    instance EmbPrj PrimitiveId

    instance EmbPrj SomeBuiltin where
      icod_ :: SomeBuiltin -> S Word32
    icod_ (BuiltinName BuiltinId
    x)   = Word32
    -> (BuiltinId -> SomeBuiltin)
    -> Arrows (Domains (BuiltinId -> SomeBuiltin)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 BuiltinId -> SomeBuiltin
    BuiltinName BuiltinId
    x
      icod_ (PrimitiveName PrimitiveId
    x) = Word32
    -> (PrimitiveId -> SomeBuiltin)
    -> Arrows (Domains (PrimitiveId -> SomeBuiltin)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 PrimitiveId -> SomeBuiltin
    PrimitiveName PrimitiveId
    x

      value :: Word32 -> R SomeBuiltin
    value = ([Word32] -> R SomeBuiltin) -> Word32 -> R SomeBuiltin
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R SomeBuiltin
    valu where
        valu :: [Word32] -> R SomeBuiltin
    valu [Word32
    0, Word32
    x] = (BuiltinId -> SomeBuiltin)
    -> Arrows
         (Constant Word32 (Domains (BuiltinId -> SomeBuiltin)))
         (R (CoDomain (BuiltinId -> SomeBuiltin)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN BuiltinId -> SomeBuiltin
    BuiltinName Word32
    x
        valu [Word32
    1, Word32
    x] = (PrimitiveId -> SomeBuiltin)
    -> Arrows
         (Constant Word32 (Domains (PrimitiveId -> SomeBuiltin)))
         (R (CoDomain (PrimitiveId -> SomeBuiltin)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN PrimitiveId -> SomeBuiltin
    PrimitiveName Word32
    x
        valu [Word32]
    _      = R SomeBuiltin
    forall a. R a
    malformed

    instance EmbPrj IsInstance where
      icod_ :: IsInstance -> S Word32
    icod_ = \case
        InstanceDef KwRange
    a  -> (KwRange -> IsInstance)
    -> Arrows (Domains (KwRange -> IsInstance)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' KwRange -> IsInstance
    InstanceDef KwRange
    a
        IsInstance
    NotInstanceDef -> IsInstance -> Arrows (Domains IsInstance) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' IsInstance
    NotInstanceDef

      value :: Word32 -> R IsInstance
    value = ([Word32] -> R IsInstance) -> Word32 -> R IsInstance
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase \case
        [Word32
    a] -> (KwRange -> IsInstance)
    -> Arrows
         (Constant Word32 (Domains (KwRange -> IsInstance)))
         (R (CoDomain (KwRange -> IsInstance)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN KwRange -> IsInstance
    InstanceDef Word32
    a
        []  -> IsInstance
    -> Arrows
         (Constant Word32 (Domains IsInstance)) (R (CoDomain IsInstance))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN IsInstance
    NotInstanceDef
        [Word32]
    _ -> R IsInstance
    forall a. R a
    malformed

    instance EmbPrj a => EmbPrj (RecordDirectives' a) where
      icod_ :: RecordDirectives' a -> S Word32
    icod_ (RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d) = (Maybe (Ranged Induction)
     -> Maybe (Ranged HasEta0)
     -> Maybe Range
     -> a
     -> RecordDirectives' a)
    -> Arrows
         (Domains
            (Maybe (Ranged Induction)
             -> Maybe (Ranged HasEta0)
             -> Maybe Range
             -> a
             -> RecordDirectives' a))
         (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    forall a.
    Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    RecordDirectives Maybe (Ranged Induction)
    a Maybe (Ranged HasEta0)
    b Maybe Range
    c a
    d

      value :: Word32 -> R (RecordDirectives' a)
    value = ([Word32] -> R (RecordDirectives' a))
    -> Word32 -> R (RecordDirectives' a)
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase \case
        [Word32
    a, Word32
    b, Word32
    c, Word32
    d] -> (Maybe (Ranged Induction)
     -> Maybe (Ranged HasEta0)
     -> Maybe Range
     -> a
     -> RecordDirectives' a)
    -> Arrows
         (Constant
            Word32
            (Domains
               (Maybe (Ranged Induction)
                -> Maybe (Ranged HasEta0)
                -> Maybe Range
                -> a
                -> RecordDirectives' a)))
         (R (CoDomain
               (Maybe (Ranged Induction)
                -> Maybe (Ranged HasEta0)
                -> Maybe Range
                -> a
                -> RecordDirectives' a)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    forall a.
    Maybe (Ranged Induction)
    -> Maybe (Ranged HasEta0)
    -> Maybe Range
    -> a
    -> RecordDirectives' a
    RecordDirectives Word32
    a Word32
    b Word32
    c Word32
    d
        [Word32]
    _ -> R (RecordDirectives' a)
    forall a. R a
    malformed

    instance EmbPrj RecordDirective where
      icod_ :: RecordDirective -> S Word32
    icod_ = \case
        Constructor Name
    a IsInstance
    b      -> Word32
    -> (Name -> IsInstance -> RecordDirective)
    -> Arrows
         (Domains (Name -> IsInstance -> RecordDirective)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    0 Name -> IsInstance -> RecordDirective
    Constructor Name
    a IsInstance
    b
        Eta Ranged HasEta0
    a                -> Word32
    -> (Ranged HasEta0 -> RecordDirective)
    -> Arrows (Domains (Ranged HasEta0 -> RecordDirective)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    1 Ranged HasEta0 -> RecordDirective
    Eta Ranged HasEta0
    a
        Induction Ranged Induction
    a          -> Word32
    -> (Ranged Induction -> RecordDirective)
    -> Arrows
         (Domains (Ranged Induction -> RecordDirective)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    2 Ranged Induction -> RecordDirective
    Induction Ranged Induction
    a
        PatternOrCopattern Range
    a -> Word32
    -> (Range -> RecordDirective)
    -> Arrows (Domains (Range -> RecordDirective)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    Word32 -> t -> Arrows (Domains t) (S Word32)
    icodeN Word32
    3 Range -> RecordDirective
    PatternOrCopattern Range
    a

      value :: Word32 -> R RecordDirective
    value = ([Word32] -> R RecordDirective) -> Word32 -> R RecordDirective
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase \case
        [Word32
    0, Word32
    a, Word32
    b] -> (Name -> IsInstance -> RecordDirective)
    -> Arrows
         (Constant Word32 (Domains (Name -> IsInstance -> RecordDirective)))
         (R (CoDomain (Name -> IsInstance -> RecordDirective)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Name -> IsInstance -> RecordDirective
    Constructor Word32
    a Word32
    b
        [Word32
    1, Word32
    a]    -> (Ranged HasEta0 -> RecordDirective)
    -> Arrows
         (Constant Word32 (Domains (Ranged HasEta0 -> RecordDirective)))
         (R (CoDomain (Ranged HasEta0 -> RecordDirective)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Ranged HasEta0 -> RecordDirective
    Eta Word32
    a
        [Word32
    2, Word32
    a]    -> (Ranged Induction -> RecordDirective)
    -> Arrows
         (Constant Word32 (Domains (Ranged Induction -> RecordDirective)))
         (R (CoDomain (Ranged Induction -> RecordDirective)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Ranged Induction -> RecordDirective
    Induction Word32
    a
        [Word32
    3, Word32
    a]    -> (Range -> RecordDirective)
    -> Arrows
         (Constant Word32 (Domains (Range -> RecordDirective)))
         (R (CoDomain (Range -> RecordDirective)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> RecordDirective
    PatternOrCopattern Word32
    a
        [Word32]
    _ -> R RecordDirective
    forall a. R a
    malformed

    instance EmbPrj Catchall where
      icod_ :: Catchall -> S Word32
    icod_ Catchall
    NoCatchall  = Catchall -> Arrows (Domains Catchall) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Catchall
    NoCatchall
      icod_ (YesCatchall Range
    x) = (Range -> Catchall)
    -> Arrows (Domains (Range -> Catchall)) (S Word32)
    forall t.
    (ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Domains t) (S Word32)
    icodeN' Range -> Catchall
    YesCatchall Range
    x

      value :: Word32 -> R Catchall
    value = ([Word32] -> R Catchall) -> Word32 -> R Catchall
    forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
    vcase [Word32] -> R Catchall
    valu where
        valu :: [Word32]
    -> Arrows
         (Constant Word32 (Domains Catchall)) (R (CoDomain Catchall))
    valu []  = Catchall
    -> Arrows
         (Constant Word32 (Domains Catchall)) (R (CoDomain Catchall))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Catchall
    NoCatchall
        valu [Word32
    x] = (Range -> Catchall)
    -> Arrows
         (Constant Word32 (Domains (Range -> Catchall)))
         (R (CoDomain (Range -> Catchall)))
    forall t.
    (VALU t (IsBase t),
     StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
     All EmbPrj (Domains t)) =>
    t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
    valuN Range -> Catchall
    YesCatchall Word32
    x
        valu [Word32]
    _   = R Catchall
    Arrows (Constant Word32 (Domains Catchall)) (R (CoDomain Catchall))
    forall a. R a
    malformed