{-# LANGUAGE Rank2Types, GADTs #-}
{-# LANGUAGE ScopedTypeVariables #-}

module PrintVisitCode where
{-# LINE 2 "src-ag/DeclBlocks.ag" #-}

import Code (Decl,Expr)
{-# LINE 9 "src-generated/PrintVisitCode.hs" #-}

{-# LINE 2 "src-ag/Patterns.ag" #-}

-- Patterns.ag imports

import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 16 "src-generated/PrintVisitCode.hs" #-}

{-# LINE 2 "src-ag/CodeSyntax.ag" #-}

import Patterns
import CommonTypes
import Data.Map(Map)
import Data.Set(Set)
{-# LINE 24 "src-generated/PrintVisitCode.hs" #-}

{-# LINE 10 "src-ag/PrintVisitCode.ag" #-}

import CommonTypes
import SequentialTypes
import Options
import CodeSyntax
import ErrorMessages
import GrammarInfo
import DeclBlocks
import Pretty

import qualified Data.Map as Map
import Data.Map(Map)
import qualified Data.Set as Set
import Data.Set(Set)
import qualified Data.Sequence as Seq
import Data.Sequence(Seq)
import UU.Scanner.Position

import Data.List(partition,intersperse,intersect,(\\))
import Data.Maybe(fromJust,isJust)
{-# LINE 47 "src-generated/PrintVisitCode.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 32 "src-ag/PrintVisitCode.ag" #-}

type PP_Docs = [PP_Doc]

ppMultiSeqH :: [PP_Doc] -> PP_Doc -> PP_Doc
ppMultiSeqH = ppMultiSeq' (>#<)

ppMultiSeqV :: [PP_Doc] -> PP_Doc -> PP_Doc
ppMultiSeqV = ppMultiSeq' (>-<)

ppMultiSeq' :: (PP_Doc -> PP_Doc -> PP_Doc) -> [PP_Doc] -> PP_Doc -> PP_Doc
ppMultiSeq' next strictArgs expr
  = foldr (\v r -> (v >#< "`seq`") `next` pp_parens r) expr strictArgs
{-# LINE 63 "src-generated/PrintVisitCode.hs" #-}
-- CGrammar ----------------------------------------------------
-- wrapper
data Inh_CGrammar  = Inh_CGrammar { Inh_CGrammar -> Options
options_Inh_CGrammar :: (Options) }
data Syn_CGrammar  = Syn_CGrammar { Syn_CGrammar -> [PP_Doc]
output_Syn_CGrammar :: (PP_Docs) }
{-# INLINABLE wrap_CGrammar #-}
wrap_CGrammar :: T_CGrammar  -> Inh_CGrammar  -> (Syn_CGrammar )
wrap_CGrammar :: T_CGrammar -> Inh_CGrammar -> Syn_CGrammar
wrap_CGrammar (T_CGrammar Identity T_CGrammar_s2
act) (Inh_CGrammar Options
_lhsIoptions) =
   Identity Syn_CGrammar -> Syn_CGrammar
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CGrammar_s2
sem <- Identity T_CGrammar_s2
act
        let arg1 :: T_CGrammar_vIn1
arg1 = Options -> T_CGrammar_vIn1
T_CGrammar_vIn1 Options
_lhsIoptions
        (T_CGrammar_vOut1 [PP_Doc]
_lhsOoutput) <- T_CGrammar_vOut1 -> Identity T_CGrammar_vOut1
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CGrammar_s2 -> T_CGrammar_v1
inv_CGrammar_s2 T_CGrammar_s2
sem T_CGrammar_vIn1
arg1)
        Syn_CGrammar -> Identity Syn_CGrammar
forall (m :: * -> *) a. Monad m => a -> m a
return ([PP_Doc] -> Syn_CGrammar
Syn_CGrammar [PP_Doc]
_lhsOoutput)
   )

-- cata
{-# INLINE sem_CGrammar #-}
sem_CGrammar :: CGrammar  -> T_CGrammar 
sem_CGrammar :: CGrammar -> T_CGrammar
sem_CGrammar ( CGrammar TypeSyns
typeSyns_ Derivings
derivings_ Set NontermIdent
wrappers_ CNonterminals
nonts_ PragmaMap
pragmas_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ PragmaMap
aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
mergeMap_ Bool
multivisit_ ) = TypeSyns
-> Derivings
-> Set NontermIdent
-> T_CNonterminals
-> PragmaMap
-> ParamMap
-> ContextMap
-> QuantMap
-> PragmaMap
-> Map
     NontermIdent
     (Map
        NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
-> Bool
-> T_CGrammar
sem_CGrammar_CGrammar TypeSyns
typeSyns_ Derivings
derivings_ Set NontermIdent
wrappers_ ( CNonterminals -> T_CNonterminals
sem_CNonterminals CNonterminals
nonts_ ) PragmaMap
pragmas_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ PragmaMap
aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
mergeMap_ Bool
multivisit_

-- semantic domain
newtype T_CGrammar  = T_CGrammar {
                                 T_CGrammar -> Identity T_CGrammar_s2
attach_T_CGrammar :: Identity (T_CGrammar_s2 )
                                 }
newtype T_CGrammar_s2  = C_CGrammar_s2 {
                                       T_CGrammar_s2 -> T_CGrammar_v1
inv_CGrammar_s2 :: (T_CGrammar_v1 )
                                       }
data T_CGrammar_s3  = C_CGrammar_s3
type T_CGrammar_v1  = (T_CGrammar_vIn1 ) -> (T_CGrammar_vOut1 )
data T_CGrammar_vIn1  = T_CGrammar_vIn1 (Options)
data T_CGrammar_vOut1  = T_CGrammar_vOut1 (PP_Docs)
{-# NOINLINE sem_CGrammar_CGrammar #-}
sem_CGrammar_CGrammar :: (TypeSyns) -> (Derivings) -> (Set NontermIdent) -> T_CNonterminals  -> (PragmaMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (Map NontermIdent (Map ConstructorIdent (Set Identifier))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) -> (Bool) -> T_CGrammar 
sem_CGrammar_CGrammar :: TypeSyns
-> Derivings
-> Set NontermIdent
-> T_CNonterminals
-> PragmaMap
-> ParamMap
-> ContextMap
-> QuantMap
-> PragmaMap
-> Map
     NontermIdent
     (Map
        NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
-> Bool
-> T_CGrammar
sem_CGrammar_CGrammar TypeSyns
_ Derivings
_ Set NontermIdent
_ T_CNonterminals
arg_nonts_ PragmaMap
_ ParamMap
_ ContextMap
_ QuantMap
_ PragmaMap
_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
_ Bool
_ = Identity T_CGrammar_s2 -> T_CGrammar
T_CGrammar (T_CGrammar_s2 -> Identity T_CGrammar_s2
forall (m :: * -> *) a. Monad m => a -> m a
return T_CGrammar_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_CGrammar_s2
st2 = let
      v1 :: T_CGrammar_v1 
      v1 :: T_CGrammar_v1
v1 = \ (T_CGrammar_vIn1 Options
_lhsIoptions) -> ( let
         _nontsX11 :: T_CNonterminals_s11
_nontsX11 = Identity T_CNonterminals_s11 -> T_CNonterminals_s11
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CNonterminals -> Identity T_CNonterminals_s11
attach_T_CNonterminals (T_CNonterminals
arg_nonts_))
         (T_CNonterminals_vOut10
T_CNonterminals_vOut10 ) = T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 T_CNonterminals_s11
_nontsX11 (T_CNonterminals_vIn10
T_CNonterminals_vIn10 )
         _lhsOoutput :: PP_Docs
         _lhsOoutput :: [PP_Doc]
_lhsOoutput = () -> [PP_Doc]
forall a. () -> [a]
rule0  ()
         __result_ :: T_CGrammar_vOut1
__result_ = [PP_Doc] -> T_CGrammar_vOut1
T_CGrammar_vOut1 [PP_Doc]
_lhsOoutput
         in T_CGrammar_vOut1
__result_ )
     in T_CGrammar_v1 -> T_CGrammar_s2
C_CGrammar_s2 T_CGrammar_v1
v1
   {-# INLINE rule0 #-}
   {-# LINE 53 "src-ag/PrintVisitCode.ag" #-}
   rule0 = \  (_ :: ()) ->
                     {-# LINE 53 "src-ag/PrintVisitCode.ag" #-}
                     []
                     {-# LINE 113 "src-generated/PrintVisitCode.hs" #-}

-- CInterface --------------------------------------------------
-- wrapper
data Inh_CInterface  = Inh_CInterface {  }
data Syn_CInterface  = Syn_CInterface {  }
{-# INLINABLE wrap_CInterface #-}
wrap_CInterface :: T_CInterface  -> Inh_CInterface  -> (Syn_CInterface )
wrap_CInterface :: T_CInterface -> Inh_CInterface -> Syn_CInterface
wrap_CInterface (T_CInterface Identity T_CInterface_s5
act) (Inh_CInterface
Inh_CInterface ) =
   Identity Syn_CInterface -> Syn_CInterface
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CInterface_s5
sem <- Identity T_CInterface_s5
act
        let arg4 :: T_CInterface_vIn4
arg4 = T_CInterface_vIn4
T_CInterface_vIn4 
        (T_CInterface_vOut4
T_CInterface_vOut4 ) <- T_CInterface_vOut4 -> Identity T_CInterface_vOut4
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CInterface_s5 -> T_CInterface_v4
inv_CInterface_s5 T_CInterface_s5
sem T_CInterface_vIn4
arg4)
        Syn_CInterface -> Identity Syn_CInterface
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CInterface
Syn_CInterface )
   )

-- cata
{-# INLINE sem_CInterface #-}
sem_CInterface :: CInterface  -> T_CInterface 
sem_CInterface :: CInterface -> T_CInterface
sem_CInterface ( CInterface CSegments
seg_ ) = T_CSegments -> T_CInterface
sem_CInterface_CInterface ( CSegments -> T_CSegments
sem_CSegments CSegments
seg_ )

-- semantic domain
newtype T_CInterface  = T_CInterface {
                                     T_CInterface -> Identity T_CInterface_s5
attach_T_CInterface :: Identity (T_CInterface_s5 )
                                     }
newtype T_CInterface_s5  = C_CInterface_s5 {
                                           T_CInterface_s5 -> T_CInterface_v4
inv_CInterface_s5 :: (T_CInterface_v4 )
                                           }
data T_CInterface_s6  = C_CInterface_s6
type T_CInterface_v4  = (T_CInterface_vIn4 ) -> (T_CInterface_vOut4 )
data T_CInterface_vIn4  = T_CInterface_vIn4 
data T_CInterface_vOut4  = T_CInterface_vOut4 
{-# NOINLINE sem_CInterface_CInterface #-}
sem_CInterface_CInterface :: T_CSegments  -> T_CInterface 
sem_CInterface_CInterface :: T_CSegments -> T_CInterface
sem_CInterface_CInterface T_CSegments
arg_seg_ = Identity T_CInterface_s5 -> T_CInterface
T_CInterface (T_CInterface_s5 -> Identity T_CInterface_s5
forall (m :: * -> *) a. Monad m => a -> m a
return T_CInterface_s5
st5) where
   {-# NOINLINE st5 #-}
   st5 :: T_CInterface_s5
st5 = let
      v4 :: T_CInterface_v4 
      v4 :: T_CInterface_v4
v4 = \ (T_CInterface_vIn4
T_CInterface_vIn4 ) -> ( let
         _segX26 :: T_CSegments_s26
_segX26 = Identity T_CSegments_s26 -> T_CSegments_s26
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CSegments -> Identity T_CSegments_s26
attach_T_CSegments (T_CSegments
arg_seg_))
         (T_CSegments_vOut25
T_CSegments_vOut25 ) = T_CSegments_s26 -> T_CSegments_v25
inv_CSegments_s26 T_CSegments_s26
_segX26 (T_CSegments_vIn25
T_CSegments_vIn25 )
         __result_ :: T_CInterface_vOut4
__result_ = T_CInterface_vOut4
T_CInterface_vOut4 
         in T_CInterface_vOut4
__result_ )
     in T_CInterface_v4 -> T_CInterface_s5
C_CInterface_s5 T_CInterface_v4
v4

-- CNonterminal ------------------------------------------------
-- wrapper
data Inh_CNonterminal  = Inh_CNonterminal {  }
data Syn_CNonterminal  = Syn_CNonterminal {  }
{-# INLINABLE wrap_CNonterminal #-}
wrap_CNonterminal :: T_CNonterminal  -> Inh_CNonterminal  -> (Syn_CNonterminal )
wrap_CNonterminal :: T_CNonterminal -> Inh_CNonterminal -> Syn_CNonterminal
wrap_CNonterminal (T_CNonterminal Identity T_CNonterminal_s8
act) (Inh_CNonterminal
Inh_CNonterminal ) =
   Identity Syn_CNonterminal -> Syn_CNonterminal
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CNonterminal_s8
sem <- Identity T_CNonterminal_s8
act
        let arg7 :: T_CNonterminal_vIn7
arg7 = T_CNonterminal_vIn7
T_CNonterminal_vIn7 
        (T_CNonterminal_vOut7
T_CNonterminal_vOut7 ) <- T_CNonterminal_vOut7 -> Identity T_CNonterminal_vOut7
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CNonterminal_s8 -> T_CNonterminal_v7
inv_CNonterminal_s8 T_CNonterminal_s8
sem T_CNonterminal_vIn7
arg7)
        Syn_CNonterminal -> Identity Syn_CNonterminal
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CNonterminal
Syn_CNonterminal )
   )

-- cata
{-# INLINE sem_CNonterminal #-}
sem_CNonterminal :: CNonterminal  -> T_CNonterminal 
sem_CNonterminal :: CNonterminal -> T_CNonterminal
sem_CNonterminal ( CNonterminal NontermIdent
nt_ [NontermIdent]
params_ Attributes
inh_ Attributes
syn_ CProductions
prods_ CInterface
inter_ ) = NontermIdent
-> [NontermIdent]
-> Attributes
-> Attributes
-> T_CProductions
-> T_CInterface
-> T_CNonterminal
sem_CNonterminal_CNonterminal NontermIdent
nt_ [NontermIdent]
params_ Attributes
inh_ Attributes
syn_ ( CProductions -> T_CProductions
sem_CProductions CProductions
prods_ ) ( CInterface -> T_CInterface
sem_CInterface CInterface
inter_ )

-- semantic domain
newtype T_CNonterminal  = T_CNonterminal {
                                         T_CNonterminal -> Identity T_CNonterminal_s8
attach_T_CNonterminal :: Identity (T_CNonterminal_s8 )
                                         }
newtype T_CNonterminal_s8  = C_CNonterminal_s8 {
                                               T_CNonterminal_s8 -> T_CNonterminal_v7
inv_CNonterminal_s8 :: (T_CNonterminal_v7 )
                                               }
data T_CNonterminal_s9  = C_CNonterminal_s9
type T_CNonterminal_v7  = (T_CNonterminal_vIn7 ) -> (T_CNonterminal_vOut7 )
data T_CNonterminal_vIn7  = T_CNonterminal_vIn7 
data T_CNonterminal_vOut7  = T_CNonterminal_vOut7 
{-# NOINLINE sem_CNonterminal_CNonterminal #-}
sem_CNonterminal_CNonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_CProductions  -> T_CInterface  -> T_CNonterminal 
sem_CNonterminal_CNonterminal :: NontermIdent
-> [NontermIdent]
-> Attributes
-> Attributes
-> T_CProductions
-> T_CInterface
-> T_CNonterminal
sem_CNonterminal_CNonterminal NontermIdent
_ [NontermIdent]
_ Attributes
_ Attributes
_ T_CProductions
arg_prods_ T_CInterface
arg_inter_ = Identity T_CNonterminal_s8 -> T_CNonterminal
T_CNonterminal (T_CNonterminal_s8 -> Identity T_CNonterminal_s8
forall (m :: * -> *) a. Monad m => a -> m a
return T_CNonterminal_s8
st8) where
   {-# NOINLINE st8 #-}
   st8 :: T_CNonterminal_s8
st8 = let
      v7 :: T_CNonterminal_v7 
      v7 :: T_CNonterminal_v7
v7 = \ (T_CNonterminal_vIn7
T_CNonterminal_vIn7 ) -> ( let
         _prodsX17 :: T_CProductions_s17
_prodsX17 = Identity T_CProductions_s17 -> T_CProductions_s17
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CProductions -> Identity T_CProductions_s17
attach_T_CProductions (T_CProductions
arg_prods_))
         _interX5 :: T_CInterface_s5
_interX5 = Identity T_CInterface_s5 -> T_CInterface_s5
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CInterface -> Identity T_CInterface_s5
attach_T_CInterface (T_CInterface
arg_inter_))
         (T_CProductions_vOut16
T_CProductions_vOut16 ) = T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 T_CProductions_s17
_prodsX17 (T_CProductions_vIn16
T_CProductions_vIn16 )
         (T_CInterface_vOut4
T_CInterface_vOut4 ) = T_CInterface_s5 -> T_CInterface_v4
inv_CInterface_s5 T_CInterface_s5
_interX5 (T_CInterface_vIn4
T_CInterface_vIn4 )
         __result_ :: T_CNonterminal_vOut7
__result_ = T_CNonterminal_vOut7
T_CNonterminal_vOut7 
         in T_CNonterminal_vOut7
__result_ )
     in T_CNonterminal_v7 -> T_CNonterminal_s8
C_CNonterminal_s8 T_CNonterminal_v7
v7

-- CNonterminals -----------------------------------------------
-- wrapper
data Inh_CNonterminals  = Inh_CNonterminals {  }
data Syn_CNonterminals  = Syn_CNonterminals {  }
{-# INLINABLE wrap_CNonterminals #-}
wrap_CNonterminals :: T_CNonterminals  -> Inh_CNonterminals  -> (Syn_CNonterminals )
wrap_CNonterminals :: T_CNonterminals -> Inh_CNonterminals -> Syn_CNonterminals
wrap_CNonterminals (T_CNonterminals Identity T_CNonterminals_s11
act) (Inh_CNonterminals
Inh_CNonterminals ) =
   Identity Syn_CNonterminals -> Syn_CNonterminals
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CNonterminals_s11
sem <- Identity T_CNonterminals_s11
act
        let arg10 :: T_CNonterminals_vIn10
arg10 = T_CNonterminals_vIn10
T_CNonterminals_vIn10 
        (T_CNonterminals_vOut10
T_CNonterminals_vOut10 ) <- T_CNonterminals_vOut10 -> Identity T_CNonterminals_vOut10
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 T_CNonterminals_s11
sem T_CNonterminals_vIn10
arg10)
        Syn_CNonterminals -> Identity Syn_CNonterminals
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CNonterminals
Syn_CNonterminals )
   )

-- cata
{-# NOINLINE sem_CNonterminals #-}
sem_CNonterminals :: CNonterminals  -> T_CNonterminals 
sem_CNonterminals :: CNonterminals -> T_CNonterminals
sem_CNonterminals CNonterminals
list = (T_CNonterminal -> T_CNonterminals -> T_CNonterminals)
-> T_CNonterminals -> [T_CNonterminal] -> T_CNonterminals
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_CNonterminal -> T_CNonterminals -> T_CNonterminals
sem_CNonterminals_Cons T_CNonterminals
sem_CNonterminals_Nil ((CNonterminal -> T_CNonterminal)
-> CNonterminals -> [T_CNonterminal]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map CNonterminal -> T_CNonterminal
sem_CNonterminal CNonterminals
list)

-- semantic domain
newtype T_CNonterminals  = T_CNonterminals {
                                           T_CNonterminals -> Identity T_CNonterminals_s11
attach_T_CNonterminals :: Identity (T_CNonterminals_s11 )
                                           }
newtype T_CNonterminals_s11  = C_CNonterminals_s11 {
                                                   T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 :: (T_CNonterminals_v10 )
                                                   }
data T_CNonterminals_s12  = C_CNonterminals_s12
type T_CNonterminals_v10  = (T_CNonterminals_vIn10 ) -> (T_CNonterminals_vOut10 )
data T_CNonterminals_vIn10  = T_CNonterminals_vIn10 
data T_CNonterminals_vOut10  = T_CNonterminals_vOut10 
{-# NOINLINE sem_CNonterminals_Cons #-}
sem_CNonterminals_Cons :: T_CNonterminal  -> T_CNonterminals  -> T_CNonterminals 
sem_CNonterminals_Cons :: T_CNonterminal -> T_CNonterminals -> T_CNonterminals
sem_CNonterminals_Cons T_CNonterminal
arg_hd_ T_CNonterminals
arg_tl_ = Identity T_CNonterminals_s11 -> T_CNonterminals
T_CNonterminals (T_CNonterminals_s11 -> Identity T_CNonterminals_s11
forall (m :: * -> *) a. Monad m => a -> m a
return T_CNonterminals_s11
st11) where
   {-# NOINLINE st11 #-}
   st11 :: T_CNonterminals_s11
st11 = let
      v10 :: T_CNonterminals_v10 
      v10 :: T_CNonterminals_v10
v10 = \ (T_CNonterminals_vIn10
T_CNonterminals_vIn10 ) -> ( let
         _hdX8 :: T_CNonterminal_s8
_hdX8 = Identity T_CNonterminal_s8 -> T_CNonterminal_s8
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CNonterminal -> Identity T_CNonterminal_s8
attach_T_CNonterminal (T_CNonterminal
arg_hd_))
         _tlX11 :: T_CNonterminals_s11
_tlX11 = Identity T_CNonterminals_s11 -> T_CNonterminals_s11
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CNonterminals -> Identity T_CNonterminals_s11
attach_T_CNonterminals (T_CNonterminals
arg_tl_))
         (T_CNonterminal_vOut7
T_CNonterminal_vOut7 ) = T_CNonterminal_s8 -> T_CNonterminal_v7
inv_CNonterminal_s8 T_CNonterminal_s8
_hdX8 (T_CNonterminal_vIn7
T_CNonterminal_vIn7 )
         (T_CNonterminals_vOut10
T_CNonterminals_vOut10 ) = T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 T_CNonterminals_s11
_tlX11 (T_CNonterminals_vIn10
T_CNonterminals_vIn10 )
         __result_ :: T_CNonterminals_vOut10
__result_ = T_CNonterminals_vOut10
T_CNonterminals_vOut10 
         in T_CNonterminals_vOut10
__result_ )
     in T_CNonterminals_v10 -> T_CNonterminals_s11
C_CNonterminals_s11 T_CNonterminals_v10
v10
{-# NOINLINE sem_CNonterminals_Nil #-}
sem_CNonterminals_Nil ::  T_CNonterminals 
sem_CNonterminals_Nil :: T_CNonterminals
sem_CNonterminals_Nil  = Identity T_CNonterminals_s11 -> T_CNonterminals
T_CNonterminals (T_CNonterminals_s11 -> Identity T_CNonterminals_s11
forall (m :: * -> *) a. Monad m => a -> m a
return T_CNonterminals_s11
st11) where
   {-# NOINLINE st11 #-}
   st11 :: T_CNonterminals_s11
st11 = let
      v10 :: T_CNonterminals_v10 
      v10 :: T_CNonterminals_v10
v10 = \ (T_CNonterminals_vIn10
T_CNonterminals_vIn10 ) -> ( let
         __result_ :: T_CNonterminals_vOut10
__result_ = T_CNonterminals_vOut10
T_CNonterminals_vOut10 
         in T_CNonterminals_vOut10
__result_ )
     in T_CNonterminals_v10 -> T_CNonterminals_s11
C_CNonterminals_s11 T_CNonterminals_v10
v10

-- CProduction -------------------------------------------------
-- wrapper
data Inh_CProduction  = Inh_CProduction {  }
data Syn_CProduction  = Syn_CProduction {  }
{-# INLINABLE wrap_CProduction #-}
wrap_CProduction :: T_CProduction  -> Inh_CProduction  -> (Syn_CProduction )
wrap_CProduction :: T_CProduction -> Inh_CProduction -> Syn_CProduction
wrap_CProduction (T_CProduction Identity T_CProduction_s14
act) (Inh_CProduction
Inh_CProduction ) =
   Identity Syn_CProduction -> Syn_CProduction
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CProduction_s14
sem <- Identity T_CProduction_s14
act
        let arg13 :: T_CProduction_vIn13
arg13 = T_CProduction_vIn13
T_CProduction_vIn13 
        (T_CProduction_vOut13
T_CProduction_vOut13 ) <- T_CProduction_vOut13 -> Identity T_CProduction_vOut13
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CProduction_s14 -> T_CProduction_v13
inv_CProduction_s14 T_CProduction_s14
sem T_CProduction_vIn13
arg13)
        Syn_CProduction -> Identity Syn_CProduction
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CProduction
Syn_CProduction )
   )

-- cata
{-# INLINE sem_CProduction #-}
sem_CProduction :: CProduction  -> T_CProduction 
sem_CProduction :: CProduction -> T_CProduction
sem_CProduction ( CProduction NontermIdent
con_ CVisits
visits_ [(NontermIdent, Type, ChildKind)]
children_ [NontermIdent]
terminals_ ) = NontermIdent
-> T_CVisits
-> [(NontermIdent, Type, ChildKind)]
-> [NontermIdent]
-> T_CProduction
sem_CProduction_CProduction NontermIdent
con_ ( CVisits -> T_CVisits
sem_CVisits CVisits
visits_ ) [(NontermIdent, Type, ChildKind)]
children_ [NontermIdent]
terminals_

-- semantic domain
newtype T_CProduction  = T_CProduction {
                                       T_CProduction -> Identity T_CProduction_s14
attach_T_CProduction :: Identity (T_CProduction_s14 )
                                       }
newtype T_CProduction_s14  = C_CProduction_s14 {
                                               T_CProduction_s14 -> T_CProduction_v13
inv_CProduction_s14 :: (T_CProduction_v13 )
                                               }
data T_CProduction_s15  = C_CProduction_s15
type T_CProduction_v13  = (T_CProduction_vIn13 ) -> (T_CProduction_vOut13 )
data T_CProduction_vIn13  = T_CProduction_vIn13 
data T_CProduction_vOut13  = T_CProduction_vOut13 
{-# NOINLINE sem_CProduction_CProduction #-}
sem_CProduction_CProduction :: (ConstructorIdent) -> T_CVisits  -> ([(Identifier,Type,ChildKind)]) -> ([Identifier]) -> T_CProduction 
sem_CProduction_CProduction :: NontermIdent
-> T_CVisits
-> [(NontermIdent, Type, ChildKind)]
-> [NontermIdent]
-> T_CProduction
sem_CProduction_CProduction NontermIdent
_ T_CVisits
arg_visits_ [(NontermIdent, Type, ChildKind)]
_ [NontermIdent]
_ = Identity T_CProduction_s14 -> T_CProduction
T_CProduction (T_CProduction_s14 -> Identity T_CProduction_s14
forall (m :: * -> *) a. Monad m => a -> m a
return T_CProduction_s14
st14) where
   {-# NOINLINE st14 #-}
   st14 :: T_CProduction_s14
st14 = let
      v13 :: T_CProduction_v13 
      v13 :: T_CProduction_v13
v13 = \ (T_CProduction_vIn13
T_CProduction_vIn13 ) -> ( let
         _visitsX32 :: T_CVisits_s32
_visitsX32 = Identity T_CVisits_s32 -> T_CVisits_s32
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CVisits -> Identity T_CVisits_s32
attach_T_CVisits (T_CVisits
arg_visits_))
         (T_CVisits_vOut31
T_CVisits_vOut31 ) = T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 T_CVisits_s32
_visitsX32 (T_CVisits_vIn31
T_CVisits_vIn31 )
         __result_ :: T_CProduction_vOut13
__result_ = T_CProduction_vOut13
T_CProduction_vOut13 
         in T_CProduction_vOut13
__result_ )
     in T_CProduction_v13 -> T_CProduction_s14
C_CProduction_s14 T_CProduction_v13
v13

-- CProductions ------------------------------------------------
-- wrapper
data Inh_CProductions  = Inh_CProductions {  }
data Syn_CProductions  = Syn_CProductions {  }
{-# INLINABLE wrap_CProductions #-}
wrap_CProductions :: T_CProductions  -> Inh_CProductions  -> (Syn_CProductions )
wrap_CProductions :: T_CProductions -> Inh_CProductions -> Syn_CProductions
wrap_CProductions (T_CProductions Identity T_CProductions_s17
act) (Inh_CProductions
Inh_CProductions ) =
   Identity Syn_CProductions -> Syn_CProductions
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CProductions_s17
sem <- Identity T_CProductions_s17
act
        let arg16 :: T_CProductions_vIn16
arg16 = T_CProductions_vIn16
T_CProductions_vIn16 
        (T_CProductions_vOut16
T_CProductions_vOut16 ) <- T_CProductions_vOut16 -> Identity T_CProductions_vOut16
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 T_CProductions_s17
sem T_CProductions_vIn16
arg16)
        Syn_CProductions -> Identity Syn_CProductions
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CProductions
Syn_CProductions )
   )

-- cata
{-# NOINLINE sem_CProductions #-}
sem_CProductions :: CProductions  -> T_CProductions 
sem_CProductions :: CProductions -> T_CProductions
sem_CProductions CProductions
list = (T_CProduction -> T_CProductions -> T_CProductions)
-> T_CProductions -> [T_CProduction] -> T_CProductions
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_CProduction -> T_CProductions -> T_CProductions
sem_CProductions_Cons T_CProductions
sem_CProductions_Nil ((CProduction -> T_CProduction) -> CProductions -> [T_CProduction]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map CProduction -> T_CProduction
sem_CProduction CProductions
list)

-- semantic domain
newtype T_CProductions  = T_CProductions {
                                         T_CProductions -> Identity T_CProductions_s17
attach_T_CProductions :: Identity (T_CProductions_s17 )
                                         }
newtype T_CProductions_s17  = C_CProductions_s17 {
                                                 T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 :: (T_CProductions_v16 )
                                                 }
data T_CProductions_s18  = C_CProductions_s18
type T_CProductions_v16  = (T_CProductions_vIn16 ) -> (T_CProductions_vOut16 )
data T_CProductions_vIn16  = T_CProductions_vIn16 
data T_CProductions_vOut16  = T_CProductions_vOut16 
{-# NOINLINE sem_CProductions_Cons #-}
sem_CProductions_Cons :: T_CProduction  -> T_CProductions  -> T_CProductions 
sem_CProductions_Cons :: T_CProduction -> T_CProductions -> T_CProductions
sem_CProductions_Cons T_CProduction
arg_hd_ T_CProductions
arg_tl_ = Identity T_CProductions_s17 -> T_CProductions
T_CProductions (T_CProductions_s17 -> Identity T_CProductions_s17
forall (m :: * -> *) a. Monad m => a -> m a
return T_CProductions_s17
st17) where
   {-# NOINLINE st17 #-}
   st17 :: T_CProductions_s17
st17 = let
      v16 :: T_CProductions_v16 
      v16 :: T_CProductions_v16
v16 = \ (T_CProductions_vIn16
T_CProductions_vIn16 ) -> ( let
         _hdX14 :: T_CProduction_s14
_hdX14 = Identity T_CProduction_s14 -> T_CProduction_s14
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CProduction -> Identity T_CProduction_s14
attach_T_CProduction (T_CProduction
arg_hd_))
         _tlX17 :: T_CProductions_s17
_tlX17 = Identity T_CProductions_s17 -> T_CProductions_s17
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CProductions -> Identity T_CProductions_s17
attach_T_CProductions (T_CProductions
arg_tl_))
         (T_CProduction_vOut13
T_CProduction_vOut13 ) = T_CProduction_s14 -> T_CProduction_v13
inv_CProduction_s14 T_CProduction_s14
_hdX14 (T_CProduction_vIn13
T_CProduction_vIn13 )
         (T_CProductions_vOut16
T_CProductions_vOut16 ) = T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 T_CProductions_s17
_tlX17 (T_CProductions_vIn16
T_CProductions_vIn16 )
         __result_ :: T_CProductions_vOut16
__result_ = T_CProductions_vOut16
T_CProductions_vOut16 
         in T_CProductions_vOut16
__result_ )
     in T_CProductions_v16 -> T_CProductions_s17
C_CProductions_s17 T_CProductions_v16
v16
{-# NOINLINE sem_CProductions_Nil #-}
sem_CProductions_Nil ::  T_CProductions 
sem_CProductions_Nil :: T_CProductions
sem_CProductions_Nil  = Identity T_CProductions_s17 -> T_CProductions
T_CProductions (T_CProductions_s17 -> Identity T_CProductions_s17
forall (m :: * -> *) a. Monad m => a -> m a
return T_CProductions_s17
st17) where
   {-# NOINLINE st17 #-}
   st17 :: T_CProductions_s17
st17 = let
      v16 :: T_CProductions_v16 
      v16 :: T_CProductions_v16
v16 = \ (T_CProductions_vIn16
T_CProductions_vIn16 ) -> ( let
         __result_ :: T_CProductions_vOut16
__result_ = T_CProductions_vOut16
T_CProductions_vOut16 
         in T_CProductions_vOut16
__result_ )
     in T_CProductions_v16 -> T_CProductions_s17
C_CProductions_s17 T_CProductions_v16
v16

-- CRule -------------------------------------------------------
-- wrapper
data Inh_CRule  = Inh_CRule {  }
data Syn_CRule  = Syn_CRule {  }
{-# INLINABLE wrap_CRule #-}
wrap_CRule :: T_CRule  -> Inh_CRule  -> (Syn_CRule )
wrap_CRule :: T_CRule -> Inh_CRule -> Syn_CRule
wrap_CRule (T_CRule Identity T_CRule_s20
act) (Inh_CRule
Inh_CRule ) =
   Identity Syn_CRule -> Syn_CRule
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CRule_s20
sem <- Identity T_CRule_s20
act
        let arg19 :: T_CRule_vIn19
arg19 = T_CRule_vIn19
T_CRule_vIn19 
        (T_CRule_vOut19
T_CRule_vOut19 ) <- T_CRule_vOut19 -> Identity T_CRule_vOut19
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CRule_s20 -> T_CRule_v19
inv_CRule_s20 T_CRule_s20
sem T_CRule_vIn19
arg19)
        Syn_CRule -> Identity Syn_CRule
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CRule
Syn_CRule )
   )

-- cata
{-# NOINLINE sem_CRule #-}
sem_CRule :: CRule  -> T_CRule 
sem_CRule :: CRule -> T_CRule
sem_CRule ( CRule NontermIdent
name_ Bool
isIn_ Bool
hasCode_ NontermIdent
nt_ NontermIdent
con_ NontermIdent
field_ Maybe NontermIdent
childnt_ Maybe Type
tp_ Pattern
pattern_ [[Char]]
rhs_ Map Int (NontermIdent, NontermIdent, Maybe Type)
defines_ Bool
owrt_ [Char]
origin_ Set (NontermIdent, NontermIdent)
uses_ Bool
explicit_ Maybe NontermIdent
mbNamed_ ) = NontermIdent
-> Bool
-> Bool
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Maybe NontermIdent
-> Maybe Type
-> T_Pattern
-> [[Char]]
-> Map Int (NontermIdent, NontermIdent, Maybe Type)
-> Bool
-> [Char]
-> Set (NontermIdent, NontermIdent)
-> Bool
-> Maybe NontermIdent
-> T_CRule
sem_CRule_CRule NontermIdent
name_ Bool
isIn_ Bool
hasCode_ NontermIdent
nt_ NontermIdent
con_ NontermIdent
field_ Maybe NontermIdent
childnt_ Maybe Type
tp_ ( Pattern -> T_Pattern
sem_Pattern Pattern
pattern_ ) [[Char]]
rhs_ Map Int (NontermIdent, NontermIdent, Maybe Type)
defines_ Bool
owrt_ [Char]
origin_ Set (NontermIdent, NontermIdent)
uses_ Bool
explicit_ Maybe NontermIdent
mbNamed_
sem_CRule ( CChildVisit NontermIdent
name_ NontermIdent
nt_ Int
nr_ Attributes
inh_ Attributes
syn_ Bool
isLast_ ) = NontermIdent
-> NontermIdent
-> Int
-> Attributes
-> Attributes
-> Bool
-> T_CRule
sem_CRule_CChildVisit NontermIdent
name_ NontermIdent
nt_ Int
nr_ Attributes
inh_ Attributes
syn_ Bool
isLast_

-- semantic domain
newtype T_CRule  = T_CRule {
                           T_CRule -> Identity T_CRule_s20
attach_T_CRule :: Identity (T_CRule_s20 )
                           }
newtype T_CRule_s20  = C_CRule_s20 {
                                   T_CRule_s20 -> T_CRule_v19
inv_CRule_s20 :: (T_CRule_v19 )
                                   }
data T_CRule_s21  = C_CRule_s21
type T_CRule_v19  = (T_CRule_vIn19 ) -> (T_CRule_vOut19 )
data T_CRule_vIn19  = T_CRule_vIn19 
data T_CRule_vOut19  = T_CRule_vOut19 
{-# NOINLINE sem_CRule_CRule #-}
sem_CRule_CRule :: (Identifier) -> (Bool) -> (Bool) -> (NontermIdent) -> (ConstructorIdent) -> (Identifier) -> (Maybe NontermIdent) -> (Maybe Type) -> T_Pattern  -> ([String]) -> (Map Int (Identifier,Identifier,Maybe Type)) -> (Bool) -> (String) -> (Set (Identifier, Identifier)) -> (Bool) -> (Maybe Identifier) -> T_CRule 
sem_CRule_CRule :: NontermIdent
-> Bool
-> Bool
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Maybe NontermIdent
-> Maybe Type
-> T_Pattern
-> [[Char]]
-> Map Int (NontermIdent, NontermIdent, Maybe Type)
-> Bool
-> [Char]
-> Set (NontermIdent, NontermIdent)
-> Bool
-> Maybe NontermIdent
-> T_CRule
sem_CRule_CRule NontermIdent
_ Bool
_ Bool
_ NontermIdent
_ NontermIdent
_ NontermIdent
_ Maybe NontermIdent
_ Maybe Type
_ T_Pattern
arg_pattern_ [[Char]]
_ Map Int (NontermIdent, NontermIdent, Maybe Type)
_ Bool
_ [Char]
_ Set (NontermIdent, NontermIdent)
_ Bool
_ Maybe NontermIdent
_ = Identity T_CRule_s20 -> T_CRule
T_CRule (T_CRule_s20 -> Identity T_CRule_s20
forall (m :: * -> *) a. Monad m => a -> m a
return T_CRule_s20
st20) where
   {-# NOINLINE st20 #-}
   st20 :: T_CRule_s20
st20 = let
      v19 :: T_CRule_v19 
      v19 :: T_CRule_v19
v19 = \ (T_CRule_vIn19
T_CRule_vIn19 ) -> ( let
         _patternX41 :: T_Pattern_s41
_patternX41 = Identity T_Pattern_s41 -> T_Pattern_s41
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s41
attach_T_Pattern (T_Pattern
arg_pattern_))
         (T_Pattern_vOut40 Pattern
_patternIcopy) = T_Pattern_s41 -> T_Pattern_v40
inv_Pattern_s41 T_Pattern_s41
_patternX41 (T_Pattern_vIn40
T_Pattern_vIn40 )
         __result_ :: T_CRule_vOut19
__result_ = T_CRule_vOut19
T_CRule_vOut19 
         in T_CRule_vOut19
__result_ )
     in T_CRule_v19 -> T_CRule_s20
C_CRule_s20 T_CRule_v19
v19
{-# NOINLINE sem_CRule_CChildVisit #-}
sem_CRule_CChildVisit :: (Identifier) -> (NontermIdent) -> (Int) -> (Attributes) -> (Attributes) -> (Bool) -> T_CRule 
sem_CRule_CChildVisit :: NontermIdent
-> NontermIdent
-> Int
-> Attributes
-> Attributes
-> Bool
-> T_CRule
sem_CRule_CChildVisit NontermIdent
_ NontermIdent
_ Int
_ Attributes
_ Attributes
_ Bool
_ = Identity T_CRule_s20 -> T_CRule
T_CRule (T_CRule_s20 -> Identity T_CRule_s20
forall (m :: * -> *) a. Monad m => a -> m a
return T_CRule_s20
st20) where
   {-# NOINLINE st20 #-}
   st20 :: T_CRule_s20
st20 = let
      v19 :: T_CRule_v19 
      v19 :: T_CRule_v19
v19 = \ (T_CRule_vIn19
T_CRule_vIn19 ) -> ( let
         __result_ :: T_CRule_vOut19
__result_ = T_CRule_vOut19
T_CRule_vOut19 
         in T_CRule_vOut19
__result_ )
     in T_CRule_v19 -> T_CRule_s20
C_CRule_s20 T_CRule_v19
v19

-- CSegment ----------------------------------------------------
-- wrapper
data Inh_CSegment  = Inh_CSegment {  }
data Syn_CSegment  = Syn_CSegment {  }
{-# INLINABLE wrap_CSegment #-}
wrap_CSegment :: T_CSegment  -> Inh_CSegment  -> (Syn_CSegment )
wrap_CSegment :: T_CSegment -> Inh_CSegment -> Syn_CSegment
wrap_CSegment (T_CSegment Identity T_CSegment_s23
act) (Inh_CSegment
Inh_CSegment ) =
   Identity Syn_CSegment -> Syn_CSegment
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CSegment_s23
sem <- Identity T_CSegment_s23
act
        let arg22 :: T_CSegment_vIn22
arg22 = T_CSegment_vIn22
T_CSegment_vIn22 
        (T_CSegment_vOut22
T_CSegment_vOut22 ) <- T_CSegment_vOut22 -> Identity T_CSegment_vOut22
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CSegment_s23 -> T_CSegment_v22
inv_CSegment_s23 T_CSegment_s23
sem T_CSegment_vIn22
arg22)
        Syn_CSegment -> Identity Syn_CSegment
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CSegment
Syn_CSegment )
   )

-- cata
{-# INLINE sem_CSegment #-}
sem_CSegment :: CSegment  -> T_CSegment 
sem_CSegment :: CSegment -> T_CSegment
sem_CSegment ( CSegment Attributes
inh_ Attributes
syn_ ) = Attributes -> Attributes -> T_CSegment
sem_CSegment_CSegment Attributes
inh_ Attributes
syn_

-- semantic domain
newtype T_CSegment  = T_CSegment {
                                 T_CSegment -> Identity T_CSegment_s23
attach_T_CSegment :: Identity (T_CSegment_s23 )
                                 }
newtype T_CSegment_s23  = C_CSegment_s23 {
                                         T_CSegment_s23 -> T_CSegment_v22
inv_CSegment_s23 :: (T_CSegment_v22 )
                                         }
data T_CSegment_s24  = C_CSegment_s24
type T_CSegment_v22  = (T_CSegment_vIn22 ) -> (T_CSegment_vOut22 )
data T_CSegment_vIn22  = T_CSegment_vIn22 
data T_CSegment_vOut22  = T_CSegment_vOut22 
{-# NOINLINE sem_CSegment_CSegment #-}
sem_CSegment_CSegment :: (Attributes) -> (Attributes) -> T_CSegment 
sem_CSegment_CSegment :: Attributes -> Attributes -> T_CSegment
sem_CSegment_CSegment Attributes
_ Attributes
_ = Identity T_CSegment_s23 -> T_CSegment
T_CSegment (T_CSegment_s23 -> Identity T_CSegment_s23
forall (m :: * -> *) a. Monad m => a -> m a
return T_CSegment_s23
st23) where
   {-# NOINLINE st23 #-}
   st23 :: T_CSegment_s23
st23 = let
      v22 :: T_CSegment_v22 
      v22 :: T_CSegment_v22
v22 = \ (T_CSegment_vIn22
T_CSegment_vIn22 ) -> ( let
         __result_ :: T_CSegment_vOut22
__result_ = T_CSegment_vOut22
T_CSegment_vOut22 
         in T_CSegment_vOut22
__result_ )
     in T_CSegment_v22 -> T_CSegment_s23
C_CSegment_s23 T_CSegment_v22
v22

-- CSegments ---------------------------------------------------
-- wrapper
data Inh_CSegments  = Inh_CSegments {  }
data Syn_CSegments  = Syn_CSegments {  }
{-# INLINABLE wrap_CSegments #-}
wrap_CSegments :: T_CSegments  -> Inh_CSegments  -> (Syn_CSegments )
wrap_CSegments :: T_CSegments -> Inh_CSegments -> Syn_CSegments
wrap_CSegments (T_CSegments Identity T_CSegments_s26
act) (Inh_CSegments
Inh_CSegments ) =
   Identity Syn_CSegments -> Syn_CSegments
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CSegments_s26
sem <- Identity T_CSegments_s26
act
        let arg25 :: T_CSegments_vIn25
arg25 = T_CSegments_vIn25
T_CSegments_vIn25 
        (T_CSegments_vOut25
T_CSegments_vOut25 ) <- T_CSegments_vOut25 -> Identity T_CSegments_vOut25
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CSegments_s26 -> T_CSegments_v25
inv_CSegments_s26 T_CSegments_s26
sem T_CSegments_vIn25
arg25)
        Syn_CSegments -> Identity Syn_CSegments
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CSegments
Syn_CSegments )
   )

-- cata
{-# NOINLINE sem_CSegments #-}
sem_CSegments :: CSegments  -> T_CSegments 
sem_CSegments :: CSegments -> T_CSegments
sem_CSegments CSegments
list = (T_CSegment -> T_CSegments -> T_CSegments)
-> T_CSegments -> [T_CSegment] -> T_CSegments
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_CSegment -> T_CSegments -> T_CSegments
sem_CSegments_Cons T_CSegments
sem_CSegments_Nil ((CSegment -> T_CSegment) -> CSegments -> [T_CSegment]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map CSegment -> T_CSegment
sem_CSegment CSegments
list)

-- semantic domain
newtype T_CSegments  = T_CSegments {
                                   T_CSegments -> Identity T_CSegments_s26
attach_T_CSegments :: Identity (T_CSegments_s26 )
                                   }
newtype T_CSegments_s26  = C_CSegments_s26 {
                                           T_CSegments_s26 -> T_CSegments_v25
inv_CSegments_s26 :: (T_CSegments_v25 )
                                           }
data T_CSegments_s27  = C_CSegments_s27
type T_CSegments_v25  = (T_CSegments_vIn25 ) -> (T_CSegments_vOut25 )
data T_CSegments_vIn25  = T_CSegments_vIn25 
data T_CSegments_vOut25  = T_CSegments_vOut25 
{-# NOINLINE sem_CSegments_Cons #-}
sem_CSegments_Cons :: T_CSegment  -> T_CSegments  -> T_CSegments 
sem_CSegments_Cons :: T_CSegment -> T_CSegments -> T_CSegments
sem_CSegments_Cons T_CSegment
arg_hd_ T_CSegments
arg_tl_ = Identity T_CSegments_s26 -> T_CSegments
T_CSegments (T_CSegments_s26 -> Identity T_CSegments_s26
forall (m :: * -> *) a. Monad m => a -> m a
return T_CSegments_s26
st26) where
   {-# NOINLINE st26 #-}
   st26 :: T_CSegments_s26
st26 = let
      v25 :: T_CSegments_v25 
      v25 :: T_CSegments_v25
v25 = \ (T_CSegments_vIn25
T_CSegments_vIn25 ) -> ( let
         _hdX23 :: T_CSegment_s23
_hdX23 = Identity T_CSegment_s23 -> T_CSegment_s23
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CSegment -> Identity T_CSegment_s23
attach_T_CSegment (T_CSegment
arg_hd_))
         _tlX26 :: T_CSegments_s26
_tlX26 = Identity T_CSegments_s26 -> T_CSegments_s26
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CSegments -> Identity T_CSegments_s26
attach_T_CSegments (T_CSegments
arg_tl_))
         (T_CSegment_vOut22
T_CSegment_vOut22 ) = T_CSegment_s23 -> T_CSegment_v22
inv_CSegment_s23 T_CSegment_s23
_hdX23 (T_CSegment_vIn22
T_CSegment_vIn22 )
         (T_CSegments_vOut25
T_CSegments_vOut25 ) = T_CSegments_s26 -> T_CSegments_v25
inv_CSegments_s26 T_CSegments_s26
_tlX26 (T_CSegments_vIn25
T_CSegments_vIn25 )
         __result_ :: T_CSegments_vOut25
__result_ = T_CSegments_vOut25
T_CSegments_vOut25 
         in T_CSegments_vOut25
__result_ )
     in T_CSegments_v25 -> T_CSegments_s26
C_CSegments_s26 T_CSegments_v25
v25
{-# NOINLINE sem_CSegments_Nil #-}
sem_CSegments_Nil ::  T_CSegments 
sem_CSegments_Nil :: T_CSegments
sem_CSegments_Nil  = Identity T_CSegments_s26 -> T_CSegments
T_CSegments (T_CSegments_s26 -> Identity T_CSegments_s26
forall (m :: * -> *) a. Monad m => a -> m a
return T_CSegments_s26
st26) where
   {-# NOINLINE st26 #-}
   st26 :: T_CSegments_s26
st26 = let
      v25 :: T_CSegments_v25 
      v25 :: T_CSegments_v25
v25 = \ (T_CSegments_vIn25
T_CSegments_vIn25 ) -> ( let
         __result_ :: T_CSegments_vOut25
__result_ = T_CSegments_vOut25
T_CSegments_vOut25 
         in T_CSegments_vOut25
__result_ )
     in T_CSegments_v25 -> T_CSegments_s26
C_CSegments_s26 T_CSegments_v25
v25

-- CVisit ------------------------------------------------------
-- wrapper
data Inh_CVisit  = Inh_CVisit {  }
data Syn_CVisit  = Syn_CVisit {  }
{-# INLINABLE wrap_CVisit #-}
wrap_CVisit :: T_CVisit  -> Inh_CVisit  -> (Syn_CVisit )
wrap_CVisit :: T_CVisit -> Inh_CVisit -> Syn_CVisit
wrap_CVisit (T_CVisit Identity T_CVisit_s29
act) (Inh_CVisit
Inh_CVisit ) =
   Identity Syn_CVisit -> Syn_CVisit
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CVisit_s29
sem <- Identity T_CVisit_s29
act
        let arg28 :: T_CVisit_vIn28
arg28 = T_CVisit_vIn28
T_CVisit_vIn28 
        (T_CVisit_vOut28
T_CVisit_vOut28 ) <- T_CVisit_vOut28 -> Identity T_CVisit_vOut28
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CVisit_s29 -> T_CVisit_v28
inv_CVisit_s29 T_CVisit_s29
sem T_CVisit_vIn28
arg28)
        Syn_CVisit -> Identity Syn_CVisit
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CVisit
Syn_CVisit )
   )

-- cata
{-# INLINE sem_CVisit #-}
sem_CVisit :: CVisit  -> T_CVisit 
sem_CVisit :: CVisit -> T_CVisit
sem_CVisit ( CVisit Attributes
inh_ Attributes
syn_ Sequence
vss_ Sequence
intra_ Bool
ordered_ ) = Attributes
-> Attributes -> T_Sequence -> T_Sequence -> Bool -> T_CVisit
sem_CVisit_CVisit Attributes
inh_ Attributes
syn_ ( Sequence -> T_Sequence
sem_Sequence Sequence
vss_ ) ( Sequence -> T_Sequence
sem_Sequence Sequence
intra_ ) Bool
ordered_

-- semantic domain
newtype T_CVisit  = T_CVisit {
                             T_CVisit -> Identity T_CVisit_s29
attach_T_CVisit :: Identity (T_CVisit_s29 )
                             }
newtype T_CVisit_s29  = C_CVisit_s29 {
                                     T_CVisit_s29 -> T_CVisit_v28
inv_CVisit_s29 :: (T_CVisit_v28 )
                                     }
data T_CVisit_s30  = C_CVisit_s30
type T_CVisit_v28  = (T_CVisit_vIn28 ) -> (T_CVisit_vOut28 )
data T_CVisit_vIn28  = T_CVisit_vIn28 
data T_CVisit_vOut28  = T_CVisit_vOut28 
{-# NOINLINE sem_CVisit_CVisit #-}
sem_CVisit_CVisit :: (Attributes) -> (Attributes) -> T_Sequence  -> T_Sequence  -> (Bool) -> T_CVisit 
sem_CVisit_CVisit :: Attributes
-> Attributes -> T_Sequence -> T_Sequence -> Bool -> T_CVisit
sem_CVisit_CVisit Attributes
_ Attributes
_ T_Sequence
arg_vss_ T_Sequence
arg_intra_ Bool
_ = Identity T_CVisit_s29 -> T_CVisit
T_CVisit (T_CVisit_s29 -> Identity T_CVisit_s29
forall (m :: * -> *) a. Monad m => a -> m a
return T_CVisit_s29
st29) where
   {-# NOINLINE st29 #-}
   st29 :: T_CVisit_s29
st29 = let
      v28 :: T_CVisit_v28 
      v28 :: T_CVisit_v28
v28 = \ (T_CVisit_vIn28
T_CVisit_vIn28 ) -> ( let
         _vssX47 :: T_Sequence_s47
_vssX47 = Identity T_Sequence_s47 -> T_Sequence_s47
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Sequence -> Identity T_Sequence_s47
attach_T_Sequence (T_Sequence
arg_vss_))
         _intraX47 :: T_Sequence_s47
_intraX47 = Identity T_Sequence_s47 -> T_Sequence_s47
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Sequence -> Identity T_Sequence_s47
attach_T_Sequence (T_Sequence
arg_intra_))
         (T_Sequence_vOut46
T_Sequence_vOut46 ) = T_Sequence_s47 -> T_Sequence_v46
inv_Sequence_s47 T_Sequence_s47
_vssX47 (T_Sequence_vIn46
T_Sequence_vIn46 )
         (T_Sequence_vOut46
T_Sequence_vOut46 ) = T_Sequence_s47 -> T_Sequence_v46
inv_Sequence_s47 T_Sequence_s47
_intraX47 (T_Sequence_vIn46
T_Sequence_vIn46 )
         __result_ :: T_CVisit_vOut28
__result_ = T_CVisit_vOut28
T_CVisit_vOut28 
         in T_CVisit_vOut28
__result_ )
     in T_CVisit_v28 -> T_CVisit_s29
C_CVisit_s29 T_CVisit_v28
v28

-- CVisits -----------------------------------------------------
-- wrapper
data Inh_CVisits  = Inh_CVisits {  }
data Syn_CVisits  = Syn_CVisits {  }
{-# INLINABLE wrap_CVisits #-}
wrap_CVisits :: T_CVisits  -> Inh_CVisits  -> (Syn_CVisits )
wrap_CVisits :: T_CVisits -> Inh_CVisits -> Syn_CVisits
wrap_CVisits (T_CVisits Identity T_CVisits_s32
act) (Inh_CVisits
Inh_CVisits ) =
   Identity Syn_CVisits -> Syn_CVisits
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CVisits_s32
sem <- Identity T_CVisits_s32
act
        let arg31 :: T_CVisits_vIn31
arg31 = T_CVisits_vIn31
T_CVisits_vIn31 
        (T_CVisits_vOut31
T_CVisits_vOut31 ) <- T_CVisits_vOut31 -> Identity T_CVisits_vOut31
forall (m :: * -> *) a. Monad m => a -> m a
return (T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 T_CVisits_s32
sem T_CVisits_vIn31
arg31)
        Syn_CVisits -> Identity Syn_CVisits
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_CVisits
Syn_CVisits )
   )

-- cata
{-# NOINLINE sem_CVisits #-}
sem_CVisits :: CVisits  -> T_CVisits 
sem_CVisits :: CVisits -> T_CVisits
sem_CVisits CVisits
list = (T_CVisit -> T_CVisits -> T_CVisits)
-> T_CVisits -> [T_CVisit] -> T_CVisits
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_CVisit -> T_CVisits -> T_CVisits
sem_CVisits_Cons T_CVisits
sem_CVisits_Nil ((CVisit -> T_CVisit) -> CVisits -> [T_CVisit]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map CVisit -> T_CVisit
sem_CVisit CVisits
list)

-- semantic domain
newtype T_CVisits  = T_CVisits {
                               T_CVisits -> Identity T_CVisits_s32
attach_T_CVisits :: Identity (T_CVisits_s32 )
                               }
newtype T_CVisits_s32  = C_CVisits_s32 {
                                       T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 :: (T_CVisits_v31 )
                                       }
data T_CVisits_s33  = C_CVisits_s33
type T_CVisits_v31  = (T_CVisits_vIn31 ) -> (T_CVisits_vOut31 )
data T_CVisits_vIn31  = T_CVisits_vIn31 
data T_CVisits_vOut31  = T_CVisits_vOut31 
{-# NOINLINE sem_CVisits_Cons #-}
sem_CVisits_Cons :: T_CVisit  -> T_CVisits  -> T_CVisits 
sem_CVisits_Cons :: T_CVisit -> T_CVisits -> T_CVisits
sem_CVisits_Cons T_CVisit
arg_hd_ T_CVisits
arg_tl_ = Identity T_CVisits_s32 -> T_CVisits
T_CVisits (T_CVisits_s32 -> Identity T_CVisits_s32
forall (m :: * -> *) a. Monad m => a -> m a
return T_CVisits_s32
st32) where
   {-# NOINLINE st32 #-}
   st32 :: T_CVisits_s32
st32 = let
      v31 :: T_CVisits_v31 
      v31 :: T_CVisits_v31
v31 = \ (T_CVisits_vIn31
T_CVisits_vIn31 ) -> ( let
         _hdX29 :: T_CVisit_s29
_hdX29 = Identity T_CVisit_s29 -> T_CVisit_s29
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CVisit -> Identity T_CVisit_s29
attach_T_CVisit (T_CVisit
arg_hd_))
         _tlX32 :: T_CVisits_s32
_tlX32 = Identity T_CVisits_s32 -> T_CVisits_s32
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CVisits -> Identity T_CVisits_s32
attach_T_CVisits (T_CVisits
arg_tl_))
         (T_CVisit_vOut28
T_CVisit_vOut28 ) = T_CVisit_s29 -> T_CVisit_v28
inv_CVisit_s29 T_CVisit_s29
_hdX29 (T_CVisit_vIn28
T_CVisit_vIn28 )
         (T_CVisits_vOut31
T_CVisits_vOut31 ) = T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 T_CVisits_s32
_tlX32 (T_CVisits_vIn31
T_CVisits_vIn31 )
         __result_ :: T_CVisits_vOut31
__result_ = T_CVisits_vOut31
T_CVisits_vOut31 
         in T_CVisits_vOut31
__result_ )
     in T_CVisits_v31 -> T_CVisits_s32
C_CVisits_s32 T_CVisits_v31
v31
{-# NOINLINE sem_CVisits_Nil #-}
sem_CVisits_Nil ::  T_CVisits 
sem_CVisits_Nil :: T_CVisits
sem_CVisits_Nil  = Identity T_CVisits_s32 -> T_CVisits
T_CVisits (T_CVisits_s32 -> Identity T_CVisits_s32
forall (m :: * -> *) a. Monad m => a -> m a
return T_CVisits_s32
st32) where
   {-# NOINLINE st32 #-}
   st32 :: T_CVisits_s32
st32 = let
      v31 :: T_CVisits_v31 
      v31 :: T_CVisits_v31
v31 = \ (T_CVisits_vIn31
T_CVisits_vIn31 ) -> ( let
         __result_ :: T_CVisits_vOut31
__result_ = T_CVisits_vOut31
T_CVisits_vOut31 
         in T_CVisits_vOut31
__result_ )
     in T_CVisits_v31 -> T_CVisits_s32
C_CVisits_s32 T_CVisits_v31
v31

-- DeclBlocks --------------------------------------------------
-- wrapper
data Inh_DeclBlocks  = Inh_DeclBlocks {  }
data Syn_DeclBlocks  = Syn_DeclBlocks {  }
{-# INLINABLE wrap_DeclBlocks #-}
wrap_DeclBlocks :: T_DeclBlocks  -> Inh_DeclBlocks  -> (Syn_DeclBlocks )
wrap_DeclBlocks :: T_DeclBlocks -> Inh_DeclBlocks -> Syn_DeclBlocks
wrap_DeclBlocks (T_DeclBlocks Identity T_DeclBlocks_s35
act) (Inh_DeclBlocks
Inh_DeclBlocks ) =
   Identity Syn_DeclBlocks -> Syn_DeclBlocks
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_DeclBlocks_s35
sem <- Identity T_DeclBlocks_s35
act
        let arg34 :: T_DeclBlocks_vIn34
arg34 = T_DeclBlocks_vIn34
T_DeclBlocks_vIn34 
        (T_DeclBlocks_vOut34
T_DeclBlocks_vOut34 ) <- T_DeclBlocks_vOut34 -> Identity T_DeclBlocks_vOut34
forall (m :: * -> *) a. Monad m => a -> m a
return (T_DeclBlocks_s35 -> T_DeclBlocks_v34
inv_DeclBlocks_s35 T_DeclBlocks_s35
sem T_DeclBlocks_vIn34
arg34)
        Syn_DeclBlocks -> Identity Syn_DeclBlocks
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_DeclBlocks
Syn_DeclBlocks )
   )

-- cata
{-# NOINLINE sem_DeclBlocks #-}
sem_DeclBlocks :: DeclBlocks  -> T_DeclBlocks 
sem_DeclBlocks :: DeclBlocks -> T_DeclBlocks
sem_DeclBlocks ( DeclBlock [Decl]
defs_ Decl
visit_ DeclBlocks
next_ ) = [Decl] -> Decl -> T_DeclBlocks -> T_DeclBlocks
sem_DeclBlocks_DeclBlock [Decl]
defs_ Decl
visit_ ( DeclBlocks -> T_DeclBlocks
sem_DeclBlocks DeclBlocks
next_ )
sem_DeclBlocks ( DeclTerminator [Decl]
defs_ Expr
result_ ) = [Decl] -> Expr -> T_DeclBlocks
sem_DeclBlocks_DeclTerminator [Decl]
defs_ Expr
result_

-- semantic domain
newtype T_DeclBlocks  = T_DeclBlocks {
                                     T_DeclBlocks -> Identity T_DeclBlocks_s35
attach_T_DeclBlocks :: Identity (T_DeclBlocks_s35 )
                                     }
newtype T_DeclBlocks_s35  = C_DeclBlocks_s35 {
                                             T_DeclBlocks_s35 -> T_DeclBlocks_v34
inv_DeclBlocks_s35 :: (T_DeclBlocks_v34 )
                                             }
data T_DeclBlocks_s36  = C_DeclBlocks_s36
type T_DeclBlocks_v34  = (T_DeclBlocks_vIn34 ) -> (T_DeclBlocks_vOut34 )
data T_DeclBlocks_vIn34  = T_DeclBlocks_vIn34 
data T_DeclBlocks_vOut34  = T_DeclBlocks_vOut34 
{-# NOINLINE sem_DeclBlocks_DeclBlock #-}
sem_DeclBlocks_DeclBlock :: ([Decl]) -> (Decl) -> T_DeclBlocks  -> T_DeclBlocks 
sem_DeclBlocks_DeclBlock :: [Decl] -> Decl -> T_DeclBlocks -> T_DeclBlocks
sem_DeclBlocks_DeclBlock [Decl]
_ Decl
_ T_DeclBlocks
arg_next_ = Identity T_DeclBlocks_s35 -> T_DeclBlocks
T_DeclBlocks (T_DeclBlocks_s35 -> Identity T_DeclBlocks_s35
forall (m :: * -> *) a. Monad m => a -> m a
return T_DeclBlocks_s35
st35) where
   {-# NOINLINE st35 #-}
   st35 :: T_DeclBlocks_s35
st35 = let
      v34 :: T_DeclBlocks_v34 
      v34 :: T_DeclBlocks_v34
v34 = \ (T_DeclBlocks_vIn34
T_DeclBlocks_vIn34 ) -> ( let
         _nextX35 :: T_DeclBlocks_s35
_nextX35 = Identity T_DeclBlocks_s35 -> T_DeclBlocks_s35
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_DeclBlocks -> Identity T_DeclBlocks_s35
attach_T_DeclBlocks (T_DeclBlocks
arg_next_))
         (T_DeclBlocks_vOut34
T_DeclBlocks_vOut34 ) = T_DeclBlocks_s35 -> T_DeclBlocks_v34
inv_DeclBlocks_s35 T_DeclBlocks_s35
_nextX35 (T_DeclBlocks_vIn34
T_DeclBlocks_vIn34 )
         __result_ :: T_DeclBlocks_vOut34
__result_ = T_DeclBlocks_vOut34
T_DeclBlocks_vOut34 
         in T_DeclBlocks_vOut34
__result_ )
     in T_DeclBlocks_v34 -> T_DeclBlocks_s35
C_DeclBlocks_s35 T_DeclBlocks_v34
v34
{-# NOINLINE sem_DeclBlocks_DeclTerminator #-}
sem_DeclBlocks_DeclTerminator :: ([Decl]) -> (Expr) -> T_DeclBlocks 
sem_DeclBlocks_DeclTerminator :: [Decl] -> Expr -> T_DeclBlocks
sem_DeclBlocks_DeclTerminator [Decl]
_ Expr
_ = Identity T_DeclBlocks_s35 -> T_DeclBlocks
T_DeclBlocks (T_DeclBlocks_s35 -> Identity T_DeclBlocks_s35
forall (m :: * -> *) a. Monad m => a -> m a
return T_DeclBlocks_s35
st35) where
   {-# NOINLINE st35 #-}
   st35 :: T_DeclBlocks_s35
st35 = let
      v34 :: T_DeclBlocks_v34 
      v34 :: T_DeclBlocks_v34
v34 = \ (T_DeclBlocks_vIn34
T_DeclBlocks_vIn34 ) -> ( let
         __result_ :: T_DeclBlocks_vOut34
__result_ = T_DeclBlocks_vOut34
T_DeclBlocks_vOut34 
         in T_DeclBlocks_vOut34
__result_ )
     in T_DeclBlocks_v34 -> T_DeclBlocks_s35
C_DeclBlocks_s35 T_DeclBlocks_v34
v34

-- DeclBlocksRoot ----------------------------------------------
-- wrapper
data Inh_DeclBlocksRoot  = Inh_DeclBlocksRoot {  }
data Syn_DeclBlocksRoot  = Syn_DeclBlocksRoot {  }
{-# INLINABLE wrap_DeclBlocksRoot #-}
wrap_DeclBlocksRoot :: T_DeclBlocksRoot  -> Inh_DeclBlocksRoot  -> (Syn_DeclBlocksRoot )
wrap_DeclBlocksRoot :: T_DeclBlocksRoot -> Inh_DeclBlocksRoot -> Syn_DeclBlocksRoot
wrap_DeclBlocksRoot (T_DeclBlocksRoot Identity T_DeclBlocksRoot_s38
act) (Inh_DeclBlocksRoot
Inh_DeclBlocksRoot ) =
   Identity Syn_DeclBlocksRoot -> Syn_DeclBlocksRoot
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_DeclBlocksRoot_s38
sem <- Identity T_DeclBlocksRoot_s38
act
        let arg37 :: T_DeclBlocksRoot_vIn37
arg37 = T_DeclBlocksRoot_vIn37
T_DeclBlocksRoot_vIn37 
        (T_DeclBlocksRoot_vOut37
T_DeclBlocksRoot_vOut37 ) <- T_DeclBlocksRoot_vOut37 -> Identity T_DeclBlocksRoot_vOut37
forall (m :: * -> *) a. Monad m => a -> m a
return (T_DeclBlocksRoot_s38 -> T_DeclBlocksRoot_v37
inv_DeclBlocksRoot_s38 T_DeclBlocksRoot_s38
sem T_DeclBlocksRoot_vIn37
arg37)
        Syn_DeclBlocksRoot -> Identity Syn_DeclBlocksRoot
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_DeclBlocksRoot
Syn_DeclBlocksRoot )
   )

-- cata
{-# INLINE sem_DeclBlocksRoot #-}
sem_DeclBlocksRoot :: DeclBlocksRoot  -> T_DeclBlocksRoot 
sem_DeclBlocksRoot :: DeclBlocksRoot -> T_DeclBlocksRoot
sem_DeclBlocksRoot ( DeclBlocksRoot DeclBlocks
blocks_ ) = T_DeclBlocks -> T_DeclBlocksRoot
sem_DeclBlocksRoot_DeclBlocksRoot ( DeclBlocks -> T_DeclBlocks
sem_DeclBlocks DeclBlocks
blocks_ )

-- semantic domain
newtype T_DeclBlocksRoot  = T_DeclBlocksRoot {
                                             T_DeclBlocksRoot -> Identity T_DeclBlocksRoot_s38
attach_T_DeclBlocksRoot :: Identity (T_DeclBlocksRoot_s38 )
                                             }
newtype T_DeclBlocksRoot_s38  = C_DeclBlocksRoot_s38 {
                                                     T_DeclBlocksRoot_s38 -> T_DeclBlocksRoot_v37
inv_DeclBlocksRoot_s38 :: (T_DeclBlocksRoot_v37 )
                                                     }
data T_DeclBlocksRoot_s39  = C_DeclBlocksRoot_s39
type T_DeclBlocksRoot_v37  = (T_DeclBlocksRoot_vIn37 ) -> (T_DeclBlocksRoot_vOut37 )
data T_DeclBlocksRoot_vIn37  = T_DeclBlocksRoot_vIn37 
data T_DeclBlocksRoot_vOut37  = T_DeclBlocksRoot_vOut37 
{-# NOINLINE sem_DeclBlocksRoot_DeclBlocksRoot #-}
sem_DeclBlocksRoot_DeclBlocksRoot :: T_DeclBlocks  -> T_DeclBlocksRoot 
sem_DeclBlocksRoot_DeclBlocksRoot :: T_DeclBlocks -> T_DeclBlocksRoot
sem_DeclBlocksRoot_DeclBlocksRoot T_DeclBlocks
arg_blocks_ = Identity T_DeclBlocksRoot_s38 -> T_DeclBlocksRoot
T_DeclBlocksRoot (T_DeclBlocksRoot_s38 -> Identity T_DeclBlocksRoot_s38
forall (m :: * -> *) a. Monad m => a -> m a
return T_DeclBlocksRoot_s38
st38) where
   {-# NOINLINE st38 #-}
   st38 :: T_DeclBlocksRoot_s38
st38 = let
      v37 :: T_DeclBlocksRoot_v37 
      v37 :: T_DeclBlocksRoot_v37
v37 = \ (T_DeclBlocksRoot_vIn37
T_DeclBlocksRoot_vIn37 ) -> ( let
         _blocksX35 :: T_DeclBlocks_s35
_blocksX35 = Identity T_DeclBlocks_s35 -> T_DeclBlocks_s35
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_DeclBlocks -> Identity T_DeclBlocks_s35
attach_T_DeclBlocks (T_DeclBlocks
arg_blocks_))
         (T_DeclBlocks_vOut34
T_DeclBlocks_vOut34 ) = T_DeclBlocks_s35 -> T_DeclBlocks_v34
inv_DeclBlocks_s35 T_DeclBlocks_s35
_blocksX35 (T_DeclBlocks_vIn34
T_DeclBlocks_vIn34 )
         __result_ :: T_DeclBlocksRoot_vOut37
__result_ = T_DeclBlocksRoot_vOut37
T_DeclBlocksRoot_vOut37 
         in T_DeclBlocksRoot_vOut37
__result_ )
     in T_DeclBlocksRoot_v37 -> T_DeclBlocksRoot_s38
C_DeclBlocksRoot_s38 T_DeclBlocksRoot_v37
v37

-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern  = Inh_Pattern {  }
data Syn_Pattern  = Syn_Pattern { Syn_Pattern -> Pattern
copy_Syn_Pattern :: (Pattern) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern  -> Inh_Pattern  -> (Syn_Pattern )
wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern
wrap_Pattern (T_Pattern Identity T_Pattern_s41
act) (Inh_Pattern
Inh_Pattern ) =
   Identity Syn_Pattern -> Syn_Pattern
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Pattern_s41
sem <- Identity T_Pattern_s41
act
        let arg40 :: T_Pattern_vIn40
arg40 = T_Pattern_vIn40
T_Pattern_vIn40 
        (T_Pattern_vOut40 Pattern
_lhsOcopy) <- T_Pattern_vOut40 -> Identity T_Pattern_vOut40
forall (m :: * -> *) a. Monad m => a -> m a
return (T_Pattern_s41 -> T_Pattern_v40
inv_Pattern_s41 T_Pattern_s41
sem T_Pattern_vIn40
arg40)
        Syn_Pattern -> Identity Syn_Pattern
forall (m :: * -> *) a. Monad m => a -> m a
return (Pattern -> Syn_Pattern
Syn_Pattern Pattern
_lhsOcopy)
   )

-- cata
{-# NOINLINE sem_Pattern #-}
sem_Pattern :: Pattern  -> T_Pattern 
sem_Pattern :: Pattern -> T_Pattern
sem_Pattern ( Constr NontermIdent
name_ Patterns
pats_ ) = NontermIdent -> T_Patterns -> T_Pattern
sem_Pattern_Constr NontermIdent
name_ ( Patterns -> T_Patterns
sem_Patterns Patterns
pats_ )
sem_Pattern ( Product Pos
pos_ Patterns
pats_ ) = Pos -> T_Patterns -> T_Pattern
sem_Pattern_Product Pos
pos_ ( Patterns -> T_Patterns
sem_Patterns Patterns
pats_ )
sem_Pattern ( Alias NontermIdent
field_ NontermIdent
attr_ Pattern
pat_ ) = NontermIdent -> NontermIdent -> T_Pattern -> T_Pattern
sem_Pattern_Alias NontermIdent
field_ NontermIdent
attr_ ( Pattern -> T_Pattern
sem_Pattern Pattern
pat_ )
sem_Pattern ( Irrefutable Pattern
pat_ ) = T_Pattern -> T_Pattern
sem_Pattern_Irrefutable ( Pattern -> T_Pattern
sem_Pattern Pattern
pat_ )
sem_Pattern ( Underscore Pos
pos_ ) = Pos -> T_Pattern
sem_Pattern_Underscore Pos
pos_

-- semantic domain
newtype T_Pattern  = T_Pattern {
                               T_Pattern -> Identity T_Pattern_s41
attach_T_Pattern :: Identity (T_Pattern_s41 )
                               }
newtype T_Pattern_s41  = C_Pattern_s41 {
                                       T_Pattern_s41 -> T_Pattern_v40
inv_Pattern_s41 :: (T_Pattern_v40 )
                                       }
data T_Pattern_s42  = C_Pattern_s42
type T_Pattern_v40  = (T_Pattern_vIn40 ) -> (T_Pattern_vOut40 )
data T_Pattern_vIn40  = T_Pattern_vIn40 
data T_Pattern_vOut40  = T_Pattern_vOut40 (Pattern)
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns  -> T_Pattern 
sem_Pattern_Constr :: NontermIdent -> T_Patterns -> T_Pattern
sem_Pattern_Constr NontermIdent
arg_name_ T_Patterns
arg_pats_ = Identity T_Pattern_s41 -> T_Pattern
T_Pattern (T_Pattern_s41 -> Identity T_Pattern_s41
forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s41
st41) where
   {-# NOINLINE st41 #-}
   st41 :: T_Pattern_s41
st41 = let
      v40 :: T_Pattern_v40 
      v40 :: T_Pattern_v40
v40 = \ (T_Pattern_vIn40
T_Pattern_vIn40 ) -> ( let
         _patsX44 :: T_Patterns_s44
_patsX44 = Identity T_Patterns_s44 -> T_Patterns_s44
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s44
attach_T_Patterns (T_Patterns
arg_pats_))
         (T_Patterns_vOut43 Patterns
_patsIcopy) = T_Patterns_s44 -> T_Patterns_v43
inv_Patterns_s44 T_Patterns_s44
_patsX44 (T_Patterns_vIn43
T_Patterns_vIn43 )
         _copy :: Pattern
_copy = Patterns -> NontermIdent -> Pattern
rule1 Patterns
_patsIcopy NontermIdent
arg_name_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = Pattern -> Pattern
forall p. p -> p
rule2 Pattern
_copy
         __result_ :: T_Pattern_vOut40
__result_ = Pattern -> T_Pattern_vOut40
T_Pattern_vOut40 Pattern
_lhsOcopy
         in T_Pattern_vOut40
__result_ )
     in T_Pattern_v40 -> T_Pattern_s41
C_Pattern_s41 T_Pattern_v40
v40
   {-# INLINE rule1 #-}
   rule1 :: Patterns -> NontermIdent -> Pattern
rule1 = \ ((Patterns
_patsIcopy) :: Patterns) NontermIdent
name_ ->
     NontermIdent -> Patterns -> Pattern
Constr NontermIdent
name_ Patterns
_patsIcopy
   {-# INLINE rule2 #-}
   rule2 :: p -> p
rule2 = \ p
_copy ->
     p
_copy
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns  -> T_Pattern 
sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern
sem_Pattern_Product Pos
arg_pos_ T_Patterns
arg_pats_ = Identity T_Pattern_s41 -> T_Pattern
T_Pattern (T_Pattern_s41 -> Identity T_Pattern_s41
forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s41
st41) where
   {-# NOINLINE st41 #-}
   st41 :: T_Pattern_s41
st41 = let
      v40 :: T_Pattern_v40 
      v40 :: T_Pattern_v40
v40 = \ (T_Pattern_vIn40
T_Pattern_vIn40 ) -> ( let
         _patsX44 :: T_Patterns_s44
_patsX44 = Identity T_Patterns_s44 -> T_Patterns_s44
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s44
attach_T_Patterns (T_Patterns
arg_pats_))
         (T_Patterns_vOut43 Patterns
_patsIcopy) = T_Patterns_s44 -> T_Patterns_v43
inv_Patterns_s44 T_Patterns_s44
_patsX44 (T_Patterns_vIn43
T_Patterns_vIn43 )
         _copy :: Pattern
_copy = Patterns -> Pos -> Pattern
rule3 Patterns
_patsIcopy Pos
arg_pos_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = Pattern -> Pattern
forall p. p -> p
rule4 Pattern
_copy
         __result_ :: T_Pattern_vOut40
__result_ = Pattern -> T_Pattern_vOut40
T_Pattern_vOut40 Pattern
_lhsOcopy
         in T_Pattern_vOut40
__result_ )
     in T_Pattern_v40 -> T_Pattern_s41
C_Pattern_s41 T_Pattern_v40
v40
   {-# INLINE rule3 #-}
   rule3 :: Patterns -> Pos -> Pattern
rule3 = \ ((Patterns
_patsIcopy) :: Patterns) Pos
pos_ ->
     Pos -> Patterns -> Pattern
Product Pos
pos_ Patterns
_patsIcopy
   {-# INLINE rule4 #-}
   rule4 :: p -> p
rule4 = \ p
_copy ->
     p
_copy
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern  -> T_Pattern 
sem_Pattern_Alias :: NontermIdent -> NontermIdent -> T_Pattern -> T_Pattern
sem_Pattern_Alias NontermIdent
arg_field_ NontermIdent
arg_attr_ T_Pattern
arg_pat_ = Identity T_Pattern_s41 -> T_Pattern
T_Pattern (T_Pattern_s41 -> Identity T_Pattern_s41
forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s41
st41) where
   {-# NOINLINE st41 #-}
   st41 :: T_Pattern_s41
st41 = let
      v40 :: T_Pattern_v40 
      v40 :: T_Pattern_v40
v40 = \ (T_Pattern_vIn40
T_Pattern_vIn40 ) -> ( let
         _patX41 :: T_Pattern_s41
_patX41 = Identity T_Pattern_s41 -> T_Pattern_s41
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s41
attach_T_Pattern (T_Pattern
arg_pat_))
         (T_Pattern_vOut40 Pattern
_patIcopy) = T_Pattern_s41 -> T_Pattern_v40
inv_Pattern_s41 T_Pattern_s41
_patX41 (T_Pattern_vIn40
T_Pattern_vIn40 )
         _copy :: Pattern
_copy = Pattern -> NontermIdent -> NontermIdent -> Pattern
rule5 Pattern
_patIcopy NontermIdent
arg_attr_ NontermIdent
arg_field_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = Pattern -> Pattern
forall p. p -> p
rule6 Pattern
_copy
         __result_ :: T_Pattern_vOut40
__result_ = Pattern -> T_Pattern_vOut40
T_Pattern_vOut40 Pattern
_lhsOcopy
         in T_Pattern_vOut40
__result_ )
     in T_Pattern_v40 -> T_Pattern_s41
C_Pattern_s41 T_Pattern_v40
v40
   {-# INLINE rule5 #-}
   rule5 :: Pattern -> NontermIdent -> NontermIdent -> Pattern
rule5 = \ ((Pattern
_patIcopy) :: Pattern) NontermIdent
attr_ NontermIdent
field_ ->
     NontermIdent -> NontermIdent -> Pattern -> Pattern
Alias NontermIdent
field_ NontermIdent
attr_ Pattern
_patIcopy
   {-# INLINE rule6 #-}
   rule6 :: p -> p
rule6 = \ p
_copy ->
     p
_copy
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern  -> T_Pattern 
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable T_Pattern
arg_pat_ = Identity T_Pattern_s41 -> T_Pattern
T_Pattern (T_Pattern_s41 -> Identity T_Pattern_s41
forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s41
st41) where
   {-# NOINLINE st41 #-}
   st41 :: T_Pattern_s41
st41 = let
      v40 :: T_Pattern_v40 
      v40 :: T_Pattern_v40
v40 = \ (T_Pattern_vIn40
T_Pattern_vIn40 ) -> ( let
         _patX41 :: T_Pattern_s41
_patX41 = Identity T_Pattern_s41 -> T_Pattern_s41
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s41
attach_T_Pattern (T_Pattern
arg_pat_))
         (T_Pattern_vOut40 Pattern
_patIcopy) = T_Pattern_s41 -> T_Pattern_v40
inv_Pattern_s41 T_Pattern_s41
_patX41 (T_Pattern_vIn40
T_Pattern_vIn40 )
         _copy :: Pattern
_copy = Pattern -> Pattern
rule7 Pattern
_patIcopy
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = Pattern -> Pattern
forall p. p -> p
rule8 Pattern
_copy
         __result_ :: T_Pattern_vOut40
__result_ = Pattern -> T_Pattern_vOut40
T_Pattern_vOut40 Pattern
_lhsOcopy
         in T_Pattern_vOut40
__result_ )
     in T_Pattern_v40 -> T_Pattern_s41
C_Pattern_s41 T_Pattern_v40
v40
   {-# INLINE rule7 #-}
   rule7 :: Pattern -> Pattern
rule7 = \ ((Pattern
_patIcopy) :: Pattern) ->
     Pattern -> Pattern
Irrefutable Pattern
_patIcopy
   {-# INLINE rule8 #-}
   rule8 :: p -> p
rule8 = \ p
_copy ->
     p
_copy
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern 
sem_Pattern_Underscore :: Pos -> T_Pattern
sem_Pattern_Underscore Pos
arg_pos_ = Identity T_Pattern_s41 -> T_Pattern
T_Pattern (T_Pattern_s41 -> Identity T_Pattern_s41
forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s41
st41) where
   {-# NOINLINE st41 #-}
   st41 :: T_Pattern_s41
st41 = let
      v40 :: T_Pattern_v40 
      v40 :: T_Pattern_v40
v40 = \ (T_Pattern_vIn40
T_Pattern_vIn40 ) -> ( let
         _copy :: Pattern
_copy = Pos -> Pattern
rule9 Pos
arg_pos_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = Pattern -> Pattern
forall p. p -> p
rule10 Pattern
_copy
         __result_ :: T_Pattern_vOut40
__result_ = Pattern -> T_Pattern_vOut40
T_Pattern_vOut40 Pattern
_lhsOcopy
         in T_Pattern_vOut40
__result_ )
     in T_Pattern_v40 -> T_Pattern_s41
C_Pattern_s41 T_Pattern_v40
v40
   {-# INLINE rule9 #-}
   rule9 :: Pos -> Pattern
rule9 = \ Pos
pos_ ->
     Pos -> Pattern
Underscore Pos
pos_
   {-# INLINE rule10 #-}
   rule10 :: p -> p
rule10 = \ p
_copy ->
     p
_copy

-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns  = Inh_Patterns {  }
data Syn_Patterns  = Syn_Patterns { Syn_Patterns -> Patterns
copy_Syn_Patterns :: (Patterns) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns  -> Inh_Patterns  -> (Syn_Patterns )
wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns
wrap_Patterns (T_Patterns Identity T_Patterns_s44
act) (Inh_Patterns
Inh_Patterns ) =
   Identity Syn_Patterns -> Syn_Patterns
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Patterns_s44
sem <- Identity T_Patterns_s44
act
        let arg43 :: T_Patterns_vIn43
arg43 = T_Patterns_vIn43
T_Patterns_vIn43 
        (T_Patterns_vOut43 Patterns
_lhsOcopy) <- T_Patterns_vOut43 -> Identity T_Patterns_vOut43
forall (m :: * -> *) a. Monad m => a -> m a
return (T_Patterns_s44 -> T_Patterns_v43
inv_Patterns_s44 T_Patterns_s44
sem T_Patterns_vIn43
arg43)
        Syn_Patterns -> Identity Syn_Patterns
forall (m :: * -> *) a. Monad m => a -> m a
return (Patterns -> Syn_Patterns
Syn_Patterns Patterns
_lhsOcopy)
   )

-- cata
{-# NOINLINE sem_Patterns #-}
sem_Patterns :: Patterns  -> T_Patterns 
sem_Patterns :: Patterns -> T_Patterns
sem_Patterns Patterns
list = (T_Pattern -> T_Patterns -> T_Patterns)
-> T_Patterns -> [T_Pattern] -> T_Patterns
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons T_Patterns
sem_Patterns_Nil ((Pattern -> T_Pattern) -> Patterns -> [T_Pattern]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map Pattern -> T_Pattern
sem_Pattern Patterns
list)

-- semantic domain
newtype T_Patterns  = T_Patterns {
                                 T_Patterns -> Identity T_Patterns_s44
attach_T_Patterns :: Identity (T_Patterns_s44 )
                                 }
newtype T_Patterns_s44  = C_Patterns_s44 {
                                         T_Patterns_s44 -> T_Patterns_v43
inv_Patterns_s44 :: (T_Patterns_v43 )
                                         }
data T_Patterns_s45  = C_Patterns_s45
type T_Patterns_v43  = (T_Patterns_vIn43 ) -> (T_Patterns_vOut43 )
data T_Patterns_vIn43  = T_Patterns_vIn43 
data T_Patterns_vOut43  = T_Patterns_vOut43 (Patterns)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern  -> T_Patterns  -> T_Patterns 
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons T_Pattern
arg_hd_ T_Patterns
arg_tl_ = Identity T_Patterns_s44 -> T_Patterns
T_Patterns (T_Patterns_s44 -> Identity T_Patterns_s44
forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s44
st44) where
   {-# NOINLINE st44 #-}
   st44 :: T_Patterns_s44
st44 = let
      v43 :: T_Patterns_v43 
      v43 :: T_Patterns_v43
v43 = \ (T_Patterns_vIn43
T_Patterns_vIn43 ) -> ( let
         _hdX41 :: T_Pattern_s41
_hdX41 = Identity T_Pattern_s41 -> T_Pattern_s41
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s41
attach_T_Pattern (T_Pattern
arg_hd_))
         _tlX44 :: T_Patterns_s44
_tlX44 = Identity T_Patterns_s44 -> T_Patterns_s44
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s44
attach_T_Patterns (T_Patterns
arg_tl_))
         (T_Pattern_vOut40 Pattern
_hdIcopy) = T_Pattern_s41 -> T_Pattern_v40
inv_Pattern_s41 T_Pattern_s41
_hdX41 (T_Pattern_vIn40
T_Pattern_vIn40 )
         (T_Patterns_vOut43 Patterns
_tlIcopy) = T_Patterns_s44 -> T_Patterns_v43
inv_Patterns_s44 T_Patterns_s44
_tlX44 (T_Patterns_vIn43
T_Patterns_vIn43 )
         _copy :: Patterns
_copy = Pattern -> Patterns -> Patterns
rule11 Pattern
_hdIcopy Patterns
_tlIcopy
         _lhsOcopy :: Patterns
         _lhsOcopy :: Patterns
_lhsOcopy = Patterns -> Patterns
forall p. p -> p
rule12 Patterns
_copy
         __result_ :: T_Patterns_vOut43
__result_ = Patterns -> T_Patterns_vOut43
T_Patterns_vOut43 Patterns
_lhsOcopy
         in T_Patterns_vOut43
__result_ )
     in T_Patterns_v43 -> T_Patterns_s44
C_Patterns_s44 T_Patterns_v43
v43
   {-# INLINE rule11 #-}
   rule11 :: Pattern -> Patterns -> Patterns
rule11 = \ ((Pattern
_hdIcopy) :: Pattern) ((Patterns
_tlIcopy) :: Patterns) ->
     (:) Pattern
_hdIcopy Patterns
_tlIcopy
   {-# INLINE rule12 #-}
   rule12 :: p -> p
rule12 = \ p
_copy ->
     p
_copy
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil ::  T_Patterns 
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil  = Identity T_Patterns_s44 -> T_Patterns
T_Patterns (T_Patterns_s44 -> Identity T_Patterns_s44
forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s44
st44) where
   {-# NOINLINE st44 #-}
   st44 :: T_Patterns_s44
st44 = let
      v43 :: T_Patterns_v43 
      v43 :: T_Patterns_v43
v43 = \ (T_Patterns_vIn43
T_Patterns_vIn43 ) -> ( let
         _copy :: [a]
_copy = () -> [a]
forall a. () -> [a]
rule13  ()
         _lhsOcopy :: Patterns
         _lhsOcopy :: Patterns
_lhsOcopy = Patterns -> Patterns
forall p. p -> p
rule14 Patterns
forall a. [a]
_copy
         __result_ :: T_Patterns_vOut43
__result_ = Patterns -> T_Patterns_vOut43
T_Patterns_vOut43 Patterns
_lhsOcopy
         in T_Patterns_vOut43
__result_ )
     in T_Patterns_v43 -> T_Patterns_s44
C_Patterns_s44 T_Patterns_v43
v43
   {-# INLINE rule13 #-}
   rule13 :: () -> [a]
rule13 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule14 #-}
   rule14 :: p -> p
rule14 = \ p
_copy ->
     p
_copy

-- Sequence ----------------------------------------------------
-- wrapper
data Inh_Sequence  = Inh_Sequence {  }
data Syn_Sequence  = Syn_Sequence {  }
{-# INLINABLE wrap_Sequence #-}
wrap_Sequence :: T_Sequence  -> Inh_Sequence  -> (Syn_Sequence )
wrap_Sequence :: T_Sequence -> Inh_Sequence -> Syn_Sequence
wrap_Sequence (T_Sequence Identity T_Sequence_s47
act) (Inh_Sequence
Inh_Sequence ) =
   Identity Syn_Sequence -> Syn_Sequence
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Sequence_s47
sem <- Identity T_Sequence_s47
act
        let arg46 :: T_Sequence_vIn46
arg46 = T_Sequence_vIn46
T_Sequence_vIn46 
        (T_Sequence_vOut46
T_Sequence_vOut46 ) <- T_Sequence_vOut46 -> Identity T_Sequence_vOut46
forall (m :: * -> *) a. Monad m => a -> m a
return (T_Sequence_s47 -> T_Sequence_v46
inv_Sequence_s47 T_Sequence_s47
sem T_Sequence_vIn46
arg46)
        Syn_Sequence -> Identity Syn_Sequence
forall (m :: * -> *) a. Monad m => a -> m a
return (Syn_Sequence
Syn_Sequence )
   )

-- cata
{-# NOINLINE sem_Sequence #-}
sem_Sequence :: Sequence  -> T_Sequence 
sem_Sequence :: Sequence -> T_Sequence
sem_Sequence Sequence
list = (T_CRule -> T_Sequence -> T_Sequence)
-> T_Sequence -> [T_CRule] -> T_Sequence
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_CRule -> T_Sequence -> T_Sequence
sem_Sequence_Cons T_Sequence
sem_Sequence_Nil ((CRule -> T_CRule) -> Sequence -> [T_CRule]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map CRule -> T_CRule
sem_CRule Sequence
list)

-- semantic domain
newtype T_Sequence  = T_Sequence {
                                 T_Sequence -> Identity T_Sequence_s47
attach_T_Sequence :: Identity (T_Sequence_s47 )
                                 }
newtype T_Sequence_s47  = C_Sequence_s47 {
                                         T_Sequence_s47 -> T_Sequence_v46
inv_Sequence_s47 :: (T_Sequence_v46 )
                                         }
data T_Sequence_s48  = C_Sequence_s48
type T_Sequence_v46  = (T_Sequence_vIn46 ) -> (T_Sequence_vOut46 )
data T_Sequence_vIn46  = T_Sequence_vIn46 
data T_Sequence_vOut46  = T_Sequence_vOut46 
{-# NOINLINE sem_Sequence_Cons #-}
sem_Sequence_Cons :: T_CRule  -> T_Sequence  -> T_Sequence 
sem_Sequence_Cons :: T_CRule -> T_Sequence -> T_Sequence
sem_Sequence_Cons T_CRule
arg_hd_ T_Sequence
arg_tl_ = Identity T_Sequence_s47 -> T_Sequence
T_Sequence (T_Sequence_s47 -> Identity T_Sequence_s47
forall (m :: * -> *) a. Monad m => a -> m a
return T_Sequence_s47
st47) where
   {-# NOINLINE st47 #-}
   st47 :: T_Sequence_s47
st47 = let
      v46 :: T_Sequence_v46 
      v46 :: T_Sequence_v46
v46 = \ (T_Sequence_vIn46
T_Sequence_vIn46 ) -> ( let
         _hdX20 :: T_CRule_s20
_hdX20 = Identity T_CRule_s20 -> T_CRule_s20
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CRule -> Identity T_CRule_s20
attach_T_CRule (T_CRule
arg_hd_))
         _tlX47 :: T_Sequence_s47
_tlX47 = Identity T_Sequence_s47 -> T_Sequence_s47
forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Sequence -> Identity T_Sequence_s47
attach_T_Sequence (T_Sequence
arg_tl_))
         (T_CRule_vOut19
T_CRule_vOut19 ) = T_CRule_s20 -> T_CRule_v19
inv_CRule_s20 T_CRule_s20
_hdX20 (T_CRule_vIn19
T_CRule_vIn19 )
         (T_Sequence_vOut46
T_Sequence_vOut46 ) = T_Sequence_s47 -> T_Sequence_v46
inv_Sequence_s47 T_Sequence_s47
_tlX47 (T_Sequence_vIn46
T_Sequence_vIn46 )
         __result_ :: T_Sequence_vOut46
__result_ = T_Sequence_vOut46
T_Sequence_vOut46 
         in T_Sequence_vOut46
__result_ )
     in T_Sequence_v46 -> T_Sequence_s47
C_Sequence_s47 T_Sequence_v46
v46
{-# NOINLINE sem_Sequence_Nil #-}
sem_Sequence_Nil ::  T_Sequence 
sem_Sequence_Nil :: T_Sequence
sem_Sequence_Nil  = Identity T_Sequence_s47 -> T_Sequence
T_Sequence (T_Sequence_s47 -> Identity T_Sequence_s47
forall (m :: * -> *) a. Monad m => a -> m a
return T_Sequence_s47
st47) where
   {-# NOINLINE st47 #-}
   st47 :: T_Sequence_s47
st47 = let
      v46 :: T_Sequence_v46 
      v46 :: T_Sequence_v46
v46 = \ (T_Sequence_vIn46
T_Sequence_vIn46 ) -> ( let
         __result_ :: T_Sequence_vOut46
__result_ = T_Sequence_vOut46
T_Sequence_vOut46 
         in T_Sequence_vOut46
__result_ )
     in T_Sequence_v46 -> T_Sequence_s47
C_Sequence_s47 T_Sequence_v46
v46