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

module AG2AspectAG where
{-# LINE 2 "src-ag/HsToken.ag" #-}

import CommonTypes
import UU.Scanner.Position(Pos)
{-# LINE 10 "src-generated/AG2AspectAG.hs" #-}

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

import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 16 "src-generated/AG2AspectAG.hs" #-}

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

-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 23 "src-generated/AG2AspectAG.hs" #-}

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

-- AbstractSyntax.ag imports
import Data.Set(Set)
import Data.Map(Map)
import Patterns    (Pattern(..),Patterns)
import Expression  (Expression(..))
import Macro --marcos
import CommonTypes
import ErrorMessages
{-# LINE 35 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 8 "src-ag/AG2AspectAG.ag" #-}

import Options

import Data.Char
import Data.List
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.Maybe

import Pretty
import PPUtil
import UU.Scanner.Position

import AbstractSyntax
import TokenDef
import CommonTypes

-- import Debug.Trace
{-# LINE 56 "src-generated/AG2AspectAG.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 28 "src-ag/AG2AspectAG.ag" #-}

pragmaAspectAG =  pp  "{-# LANGUAGE EmptyDataDecls, NoMonomorphismRestriction , TypeSynonymInstances, MultiParamTypeClasses, FlexibleContexts, FlexibleInstances #-}"

{-# LINE 63 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 33 "src-ag/AG2AspectAG.ag" #-}

ppName l = ppListSep "" "" "_" l
{-# LINE 68 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 70 "src-ag/AG2AspectAG.ag" #-}

type FieldMap  = [(Identifier, Type)]
type DataTypes = Map.Map NontermIdent (Map.Map ConstructorIdent FieldMap)
{-# LINE 74 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 342 "src-ag/AG2AspectAG.ag" #-}

filterAtts newAtts = filter (\att -> Map.member (identifier att) newAtts)
filterNotAtts newAtts = filter (\att -> not (Map.member (identifier att) newAtts))

defAtt  att = "data " >|< attTName att >|< "; " >|< attName att >|< " = proxy :: Proxy " >|< attTName att
attName att = pp $ "att_" ++ att
attTName att = pp $ "Att_" ++ att


defAttRec  recPref ppNt atts noGroup  =
           let     recName    = ppName [recPref, ppNt]
                   fields     = ppCommas (map (\(a,t) -> ppName [pp a, recName ] >|< " ::" >|< ppShow t) (groupAtts atts noGroup))
           in
                   "data " >|<  recName >|< " = " >|< recName >|< " { " >|<   fields  >|< " }"

groupAtts atts noGroup = (Map.toAscList . Map.difference atts) noGroup

-- it defines selectors with the form:
-- l1_nt_prod(x, _, .., _) = x
-- ln_nt_prod(_, .., _, x) = x
defLocalAtts prodName total actual (l:ls) =  ppName [pp l, prodName] >|<
                                             ppListSep "(" ")" ","  (replicate (actual-1) "_" ++ "x" : replicate (total-actual) "_") >|<
                                             pp " = x" >-<
                                             defLocalAtts prodName total (actual+1) ls
defLocalAtts _        _     _      []     =  empty

{-# LINE 103 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 397 "src-ag/AG2AspectAG.ag" #-}

ntsList att ppNtL = "nts_" ++ att ++ " = " >|<  ppListSep "" "" " .*. " ((map fst ppNtL) ++ [pp "hNil"])

filterNts att = filter ( Map.member (identifier att) . snd )
{-# LINE 110 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 455 "src-ag/AG2AspectAG.ag" #-}

data PPRule = PPRule Identifier Identifier Bool ([(Identifier,Type)] -> [Identifier] -> PP_Doc)

ppRule (field,attr) owrt def = PPRule field attr owrt def
ruleField (PPRule field  _     _     _  ) = field
ruleAttr  (PPRule _      attr  _     _  ) = attr
ruleOwrt  (PPRule _      _     owrt  _  ) = owrt
ruleDef   (PPRule _      _     _     def) = def

{-# LINE 122 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 494 "src-ag/AG2AspectAG.ag" #-}


defInhGRule ppNt prodName newNT newProd ch rules inhNoGroup synNoGroup chids locals =
                       let  ppAtt = ppName [pp "inh", prodName]
                            ppR =  ppAtt >|< pp " = inhdefM att_inh nts_group $" >-<
                                   indent 4  "do " >-<
                                   indent 5  "loc <- at loc" >-<
                                   indent 5  "lhs <- at lhs" >-<
                                   indent 5  ch >-<
                                   indent 5  "return $"  >-<
                                   indent 6  (foldr (>-<) (pp "emptyRecord") (map (chGRule ppNt prodName rules inhNoGroup synNoGroup chids locals) chids))
                       in  if (newNT || (not newNT && newProd))
                           then (ppR, [ ppAtt ])
                           else (empty, [])

chGRule ppNt prodName rules inhNoGroup synNoGroup chids locals (idCh,tp) =
                       let  chName = ppName [pp "ch", pp idCh, prodName]
                            ppTp   = ppShow tp
                            chRules = ppCommas $ mapGRuleDefs (== idCh)  rules inhNoGroup synNoGroup chids locals
                       in   if (isNonterminal tp)
                             then   chName >|< ".=." >-<
                                    indent 1 "InhG_" >|< ppShow tp >|< pp " {"  >-<
                                    indent 2 chRules >-<
                                    indent 1 "} .*. "
                             else   empty


defSynGRule ppNt prod newNT newProd ch rules inhNoGroup synNoGroup chids locals =
                       let  ppAtt = ppName [pp "syn", ppNt, pp prod]
                            ppTAtt = "SynG_" >|< ppNt
                            ppR =  ppAtt >|< pp " = syndefM att_syn $" >-<
                                   indent 4  "do " >-<
                                   indent 5  "loc <- at loc" >-<
                                   indent 5  "lhs <- at lhs" >-<
                                   indent 5  ch >-<
                                   indent 5  "return $"  >-<
                                   indent 6  ppTAtt >|< pp " {"  >-<
                                   indent 7  (ppCommas $ mapGRuleDefs ((== "lhs") . show)  rules inhNoGroup synNoGroup chids locals) >-<
                                   indent 6  "}"
                       in  if (newNT || (not newNT && newProd))
                           then (ppR, [ ppAtt ])
                           else (empty, [])

defLocRule ppNt prod newNT newProd ch rules inhNoGroup synNoGroup chids locals =
                       let  ppAtt  = ppName [pp "loc", ppNt, pp prod]
                            ppTAtt = ppName [pp "Loc", ppNt, pp prod]
                            ppR =    ppAtt >|< pp " = locdefM att_loc $" >-<
                                     indent 4  "do " >-<
                                     indent 5  "loc <- at loc" >-<
                                     indent 5  "lhs <- at lhs" >-<
                                     indent 5  ch >-<
                                     indent 5  "return $"  >-<
                                     indent 6  (ppListSep "(" ")" "," $ mapLRuleDefs rules inhNoGroup synNoGroup chids locals)
                       in  (ppR, [ ppAtt ])

defInstRules ppNt prod newNT newProd ch rules chids locals
                                             = let  ppAsp     = ppName [pp "inst", ppNt, pp prod]
                                                    instRules = filter ((=="inst") . show . ruleField) rules
                                                    ppAtt att = ppListSep "`ext` " "" "_" [pp "inst_ch", pp att, ppNt, pp prod]
                                               in   (  ppAsp >|< pp " = emptyRule " >|< (map (ppAtt . ruleAttr) instRules) >-<
                                                       (vlist $ map (defInstRule  ppNt prod ch chids locals) instRules)
                                                    ,  [ ppAsp ])


defInstRule  ppNt prod ch chids locals rule =
                       let  ppAtt  = ppName [pp "ch", pp (ruleAttr rule), ppNt, pp prod]
                       in   pp "inst_" >|< ppAtt >|< pp " = instdefM " >|< ppAtt >|< pp " $" >-<
                            indent 4  "do " >-<
                            indent 5  "loc <- at loc" >-<
                            indent 5  "lhs <- at lhs" >-<
                            indent 5  ch >-<
                            indent 5  "return $"  >-<
                            indent 6  ((ruleDef rule) chids locals)


defSynRules ppNt prod newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
                                             = let  synRules     = filter ( (=="lhs") . show . ruleField)  rules
                                                    ngRules      = filter ((flip elem synNoGroup) . getName . ruleAttr) synRules
                                                    (ppR, ppRA)  = unzip $  map (defSynRule True ppNt prod newNT newProd newAtts ch chids locals) ngRules
                                               in   (vlist ppR, concat ppRA )

modSynRules ppNt prod newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
                                             = let  synRules     = filter ( (=="lhs") . show . ruleField)  rules
                                                    ngRules      = filter ((flip elem synNoGroup) . getName . ruleAttr) synRules
                                                    (ppR, ppRA)  = unzip $  map (defSynRule False ppNt prod newNT newProd newAtts ch chids locals) ngRules
                                               in   (vlist ppR, concat ppRA )

defSynRule  new ppNt prod newNT newProd newAtts ch chids locals rule =
                       let  att    = ruleAttr rule
                            newAtt = Map.member att newAtts
                            owrt   = ruleOwrt rule
                            ppAtt  = ppName [pp att, pp (if new then "syn" else "synM"), ppNt, pp prod]
                            ppR def =   ppAtt >|< pp (" = " ++ def ++ " ") >|< attName (show att) >|< pp " $" >-<
                                        indent 4  "do " >-<
                                        indent 5  "loc <- at loc" >-<
                                        indent 5  "lhs <- at lhs" >-<
                                        indent 5  ch >-<
                                        indent 5  "return $"  >-<
                                        indent 6  ((ruleDef rule) chids locals)
                       in   
                           if new
                           then  if (not owrt && (newNT || (not newNT && newProd) || newAtt))
                                 then  (ppR "syndefM", [ ppAtt ])
                                 else  (empty,         [])
                           else  if owrt
                                 then  (ppR "synmodM", [ ppAtt ])
                                 else  (empty,         [])



defInhRules ppNt prodName newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
                                             = let  ngRules      = filter ((flip elem inhNoGroup) . getName . ruleAttr) rules
                                                    (ppR, ppRA)  = unzip $ map (defInhRule True  ppNt prodName newNT newProd newAtts ch ngRules inhNoGroup synNoGroup chids locals) inhNoGroup
                                               in   (vlist ppR, concat ppRA)

modInhRules ppNt prodName newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals
                                             = let  ngRules      = filter ((flip elem inhNoGroup) . getName . ruleAttr) rules
                                                    (ppR, ppRA)  = unzip $ map (defInhRule  False ppNt prodName newNT newProd newAtts ch ngRules inhNoGroup synNoGroup chids locals) inhNoGroup
                                               in   (vlist ppR, concat ppRA)


defInhRule new ppNt prodName newNT newProd newAtts ch rules inhNoGroup synNoGroup chids locals att =
                       let  ppAtt       =  ppName [pp att, pp (if new then "inh" else "inhM"),prodName]
                            newAtt      =  Map.member (identifier att) newAtts
                            chRMaybe    =  map (chRule new ppNt prodName att rules inhNoGroup synNoGroup chids locals) chids
                            chR         =  [ x | (Just x) <- chRMaybe ]
                            ppR def  =  ppAtt >|< pp (" = " ++ def ++ " ") >|< attName att >|< " nts_" >|< att >|< " $" >-<
                                        indent 4  "do " >-<
                                        indent 5  "loc <- at loc" >-<
                                        indent 5  "lhs <- at lhs" >-<
                                        indent 5  ch >-<
                                        indent 5  "return $"  >-<
                                        indent 6  (foldr (>-<) (pp "emptyRecord") chR)
                       in
                           if new
                           then  if (newNT || (not newNT && newProd) || newAtt)
                                 then  (ppR "inhdefM", [ ppAtt ])
                                 else  (empty,         [])
                           else  if (not . null) chR
                                 then  (ppR "inhmodM", [ ppAtt ])
                                 else  (empty,         [])


chRule new ppNt prodName att rules inhNoGroup synNoGroup chids locals (idCh,tp) =
                       let  chName = ppName [pp "ch", pp idCh, prodName]
                            ppTp   = ppShow tp
                            chRule = inhRuleDef new (== idCh) (== att) rules inhNoGroup synNoGroup chids locals  -- it's supposed to be only one
                       in   if (isNonterminal tp && (not . null) chRule)
                             then   Just $ chName >|< ".=. (" >|< chRule >|< ") .*. "
                             else   Nothing


mapLRuleDefs rules inhNoGroup synNoGroup chids locals
                 = map appSnd $ sortBy cmpField $ filter ((== "loc") . show . ruleField)  rules
                                      where cmpField r1 r2 = compare (ruleField r1) (ruleField r2)
                                            appSnd rule = (ruleDef rule)  chids locals


mapGRuleDefs filt rules inhNoGroup synNoGroup chids locals
                 = map appSnd $ sortBy cmpField $ filter (not . (flip elem inhNoGroup) . getName . ruleAttr)
                                                $ filter (not . (flip elem synNoGroup) . getName . ruleAttr)
                                                $ filter ( filt . ruleField)  rules
                                      where cmpField r1 r2 = compare (ruleField r1) (ruleField r2)
                                            appSnd rule = (ruleDef rule)  chids locals

inhRuleDef new filt1 filt2 rules inhNoGroup synNoGroup chids locals
                 = map appSnd $ sortBy cmpField $ filter ( (== not new) . ruleOwrt)
                                                $ filter ((flip elem inhNoGroup) . getName . ruleAttr)
                                                $ filter ( filt2 . getName . ruleAttr)
                                                $ filter ( filt1 . ruleField)  rules
                                      where cmpField r1 r2 = compare (ruleField r1) (ruleField r2)
                                            appSnd rule = (ruleDef rule)  chids locals

defRule ppNt (field,att) noGroup rhs = \chids locals ->
                                     let ppAtt = if (elem (getName att) noGroup)
                                                  then empty
                                                  else case (show field) of
                                                        "lhs"     -> att >|< "_" >|< pp "SynG" >|< pp "_" >|< ppNt  >|< " = "
                                                        "loc"     -> empty
                                                        "inst"    -> empty
                                                        otherwise -> att >|< "_" >|< pp "InhG" >|< pp "_" >|<
                                                                     (maybe (error $ "lhs field " ++ show field ++" is not a child")
                                                                            ppShow (lookup field chids))
                                                                     >|< " = "
                                     in  ppAtt >|< (rhs noGroup field chids locals)


rhsRule ppNt ppProd tks noGroup field chids locals  =  vlist . lines2PP . (map (token2PP ppNt ppProd field chids locals noGroup )) $ tks


lines2PP [] = []
lines2PP xs = map line2PP . shiftLeft . getLines $ xs


token2PP ppNt ppProd field chids locals noGroup  tk
  = case tk of
      AGLocal var pos _        -> (pos, if (elem var locals)
                                        then  (ppListSep "(" "" "_" [pp var, ppNt, ppProd]) >|< pp " (loc # att_loc)) "
                                        else  pp var)
      AGField field attr pos _ -> let ppChT =    maybe (error $ "rhs field " ++ show field ++ " is not a child") ppShow (lookup field chids)
                                      ppAtt =    case (show field) of
                                                 "lhs"      ->  attName "inh"
                                                 "loc"      ->  attName "loc"
                                                 otherwise  ->  attName "syn"
                                      ppSubAtt = case (show field) of
                                                 "lhs"      -> ppName [pp (getName attr), pp "InhG", ppNt]
                                                 "loc"      -> ppName [pp (getName attr), ppNt, ppProd]
                                                 otherwise  -> ppName [pp (getName attr), pp "SynG", ppChT]
                                  in  (pos, if ((elem (getName attr) noGroup) && ((show field) /= "loc"))
                                             then pp "(" >|< pp (getName field)  >|< " # " >|< attName (getName attr) >|< pp ")"
                                             else pp "(" >|< ppSubAtt >|< " (" >|< pp (getName field) >|< " # " >|< ppAtt >|< ")) ")
      HsToken value pos        -> (pos, pp value)
      CharToken value pos      -> (pos, pp (show value))
      StrToken value pos       -> (pos, pp (show value))
      Err mesg pos             -> (pos, pp $ " ***" ++ mesg ++ "*** ")

line2PP ts =         let f (p,t) r = let ct = column p
                                     in \c -> pp (spaces (ct-c)) >|< t >|< r (length (show t) +ct)
                         spaces x | x < 0 = ""
                                  | otherwise = replicate x ' '
                     in foldr f (pp . const "") ts 1

{-# LINE 347 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 721 "src-ag/AG2AspectAG.ag" #-}

ppMacro (Macro con children) = "( atts_" >|< show con >|< ", " >|<  ppListSep "" "" " <.> " ppChildren  >|<")"
                where   ppChildren = map  ppChild children
                        ppChild (RuleChild  ch n) = chName ch >|< " ==> " >|< ppMacro n
                        ppChild (ChildChild ch n) = chName ch >|< " --> " >|< n
                        ppChild (ValueChild ch n) = chName ch >|< " ~~> " >|< n
                        chName ch = ppName [pp "ch", pp ch, pp con]
{-# LINE 357 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 754 "src-ag/AG2AspectAG.ag" #-}

ppNoGroupAtts syn noGroup = let synatts = Map.keys $ Map.filterWithKey (\att _ -> elem (getName att) noGroup) syn
                            in  map (flip (>|<) "_inh") noGroup ++  map (flip (>|<) "_syn") synatts

ruleName att prodName = ppName [att,prodName]

elemNT a b = False
{-# LINE 367 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 797 "src-ag/AG2AspectAG.ag" #-}

attTypes atts = map (\(a,t) -> "(HCons (LVPair (Proxy Att_" >|< a >|< ") " >|< ppShow t >|< ") ") $ Map.toAscList atts
{-# LINE 372 "src-generated/AG2AspectAG.hs" #-}

{-# LINE 851 "src-ag/AG2AspectAG.ag" #-}

attVars atts = map (\(a,_) -> "_" >|< a >|< " ") $ Map.toAscList atts
attFields atts noGroup ppNt =
     let ng = map (\(a,_) -> attName (getName a) >|< " .=. _" >|< a >|< " .*. ") $ Map.toAscList noGroup
         g  = ppCommas $ map (\(a,_) -> ppName [pp a, pp "InhG",ppNt]  >|< "= _" >|< a) $ Map.toAscList $ Map.difference atts noGroup
     in "(" >|< ng >|< "att_inh .=. " >|< ppName [pp "InhG", ppNt] >|< " { " >|< g >|< " } .*. emptyRecord)"
{-# LINE 381 "src-generated/AG2AspectAG.hs" #-}
-- Child -------------------------------------------------------
-- wrapper
data Inh_Child  = Inh_Child { ext_Inh_Child :: (Maybe String), inhMap_Inh_Child :: (Map Identifier Attributes), inhNoGroup_Inh_Child :: ([String]), newAtts_Inh_Child :: ( Attributes ), o_noGroup_Inh_Child :: ([String]), o_rename_Inh_Child :: (Bool), ppNt_Inh_Child :: (PP_Doc), ppProd_Inh_Child :: (PP_Doc), synMap_Inh_Child :: (Map Identifier Attributes), synNoGroup_Inh_Child :: ([String]) }
data Syn_Child  = Syn_Child { idCL_Syn_Child :: ([(Identifier,Type)]), ppCSF_Syn_Child :: ([(Identifier,(PP_Doc,PP_Doc))]), ppDL_Syn_Child :: ([PP_Doc]), ppL_Syn_Child :: (PP_Doc), ppLI_Syn_Child :: ([PP_Doc]), ppR_Syn_Child :: (PP_Doc), prdInh_Syn_Child :: (Attributes) }
{-# INLINABLE wrap_Child #-}
wrap_Child :: T_Child  -> Inh_Child  -> (Syn_Child )
wrap_Child (T_Child act) (Inh_Child _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg1 = T_Child_vIn1 _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup
        (T_Child_vOut1 _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh) <- return (inv_Child_s2 sem arg1)
        return (Syn_Child _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh)
   )

-- cata
{-# INLINE sem_Child #-}
sem_Child :: Child  -> T_Child 
sem_Child ( Child name_ tp_ kind_ ) = sem_Child_Child name_ tp_ kind_

-- semantic domain
newtype T_Child  = T_Child {
                           attach_T_Child :: Identity (T_Child_s2 )
                           }
newtype T_Child_s2  = C_Child_s2 {
                                 inv_Child_s2 :: (T_Child_v1 )
                                 }
data T_Child_s3  = C_Child_s3
type T_Child_v1  = (T_Child_vIn1 ) -> (T_Child_vOut1 )
data T_Child_vIn1  = T_Child_vIn1 (Maybe String) (Map Identifier Attributes) ([String]) ( Attributes ) ([String]) (Bool) (PP_Doc) (PP_Doc) (Map Identifier Attributes) ([String])
data T_Child_vOut1  = T_Child_vOut1 ([(Identifier,Type)]) ([(Identifier,(PP_Doc,PP_Doc))]) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (Attributes)
{-# NOINLINE sem_Child_Child #-}
sem_Child_Child :: (Identifier) -> (Type) -> (ChildKind) -> T_Child 
sem_Child_Child arg_name_ arg_tp_ arg_kind_ = T_Child (return st2) where
   {-# NOINLINE st2 #-}
   st2 = let
      v1 :: T_Child_v1 
      v1 = \ (T_Child_vIn1 _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup) -> ( let
         _chnt = rule0 arg_name_ arg_tp_
         _inh = rule1 _chnt _lhsIinhMap
         _syn = rule2 _chnt _lhsIsynMap
         _lhsOprdInh :: Attributes
         _lhsOprdInh = rule3 _inh
         _ppCh = rule4 arg_name_
         _ppTCh = rule5 arg_tp_
         _chName = rule6 _lhsIppNt _lhsIppProd _ppCh
         _lhsOppDL :: [PP_Doc]
         _lhsOppDL = rule7 _chName _ppTCh arg_kind_
         _chLabel = rule8 _chName
         _chTLabel = rule9 _chName
         _lhsOppL :: PP_Doc
         _lhsOppL = rule10 _chLabel _chTLabel _ppTCh arg_kind_
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule11 _chLabel _chTLabel
         _lhsOppR :: PP_Doc
         _lhsOppR = rule12 _lhsIppNt _lhsIppProd arg_name_
         _lhsOidCL :: [(Identifier,Type)]
         _lhsOidCL = rule13 arg_name_ arg_tp_
         _lhsOppCSF :: [(Identifier,(PP_Doc,PP_Doc))]
         _lhsOppCSF = rule14 _chLabel arg_kind_ arg_name_ arg_tp_
         __result_ = T_Child_vOut1 _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh
         in __result_ )
     in C_Child_s2 v1
   {-# INLINE rule0 #-}
   {-# LINE 19 "src-ag/DistChildAttr.ag" #-}
   rule0 = \ name_ tp_ ->
                       {-# LINE 19 "src-ag/DistChildAttr.ag" #-}
                       case tp_ of
                         NT nt _ _ -> nt
                         Self      -> error ("The type of child " ++ show name_ ++ " should not be a Self type.")
                         Haskell t -> identifier ""
                       {-# LINE 452 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule1 #-}
   {-# LINE 23 "src-ag/DistChildAttr.ag" #-}
   rule1 = \ _chnt ((_lhsIinhMap) :: Map Identifier Attributes) ->
                      {-# LINE 23 "src-ag/DistChildAttr.ag" #-}
                      Map.findWithDefault Map.empty _chnt     _lhsIinhMap
                      {-# LINE 458 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule2 #-}
   {-# LINE 24 "src-ag/DistChildAttr.ag" #-}
   rule2 = \ _chnt ((_lhsIsynMap) :: Map Identifier Attributes) ->
                      {-# LINE 24 "src-ag/DistChildAttr.ag" #-}
                      Map.findWithDefault Map.empty _chnt     _lhsIsynMap
                      {-# LINE 464 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule3 #-}
   {-# LINE 67 "src-ag/AG2AspectAG.ag" #-}
   rule3 = \ _inh ->
                              {-# LINE 67 "src-ag/AG2AspectAG.ag" #-}
                              _inh
                              {-# LINE 470 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule4 #-}
   {-# LINE 182 "src-ag/AG2AspectAG.ag" #-}
   rule4 = \ name_ ->
                                                      {-# LINE 182 "src-ag/AG2AspectAG.ag" #-}
                                                      pp name_
                                                      {-# LINE 476 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule5 #-}
   {-# LINE 183 "src-ag/AG2AspectAG.ag" #-}
   rule5 = \ tp_ ->
                                                      {-# LINE 183 "src-ag/AG2AspectAG.ag" #-}
                                                      ppShow tp_
                                                      {-# LINE 482 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule6 #-}
   {-# LINE 184 "src-ag/AG2AspectAG.ag" #-}
   rule6 = \ ((_lhsIppNt) :: PP_Doc) ((_lhsIppProd) :: PP_Doc) _ppCh ->
                                                      {-# LINE 184 "src-ag/AG2AspectAG.ag" #-}
                                                      ppName [_ppCh    , _lhsIppNt, _lhsIppProd]
                                                      {-# LINE 488 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule7 #-}
   {-# LINE 242 "src-ag/AG2AspectAG.ag" #-}
   rule7 = \ _chName _ppTCh kind_ ->
                                                    {-# LINE 242 "src-ag/AG2AspectAG.ag" #-}
                                                    case kind_ of
                                                     ChildSyntax    ->  [ _chName      >|< pp " :: " >|< _ppTCh     ]
                                                     _              ->  []
                                                    {-# LINE 496 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule8 #-}
   {-# LINE 285 "src-ag/AG2AspectAG.ag" #-}
   rule8 = \ _chName ->
                                                     {-# LINE 285 "src-ag/AG2AspectAG.ag" #-}
                                                     "ch_" >|< _chName
                                                     {-# LINE 502 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule9 #-}
   {-# LINE 286 "src-ag/AG2AspectAG.ag" #-}
   rule9 = \ _chName ->
                                                     {-# LINE 286 "src-ag/AG2AspectAG.ag" #-}
                                                     "Ch_" >|< _chName
                                                     {-# LINE 508 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule10 #-}
   {-# LINE 287 "src-ag/AG2AspectAG.ag" #-}
   rule10 = \ _chLabel _chTLabel _ppTCh kind_ ->
                                                     {-# LINE 287 "src-ag/AG2AspectAG.ag" #-}
                                                     "data " >|< _chTLabel     >|< "; " >|< _chLabel     >|< pp " = proxy :: " >|<
                                                     case kind_ of
                                                      ChildSyntax    ->  "Proxy " >|< "(" >|< _chTLabel     >|< ", " >|< _ppTCh     >|< ")"
                                                      _              ->  "SemType " >|< _ppTCh     >|< pp " nt =>  Proxy " >|<
                                                                         "(" >|< _chTLabel     >|< ", nt)"
                                                     {-# LINE 518 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule11 #-}
   {-# LINE 293 "src-ag/AG2AspectAG.ag" #-}
   rule11 = \ _chLabel _chTLabel ->
                                                     {-# LINE 293 "src-ag/AG2AspectAG.ag" #-}
                                                     [ _chLabel    , _chTLabel     ]
                                                     {-# LINE 524 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule12 #-}
   {-# LINE 451 "src-ag/AG2AspectAG.ag" #-}
   rule12 = \ ((_lhsIppNt) :: PP_Doc) ((_lhsIppProd) :: PP_Doc) name_ ->
                                                     {-# LINE 451 "src-ag/AG2AspectAG.ag" #-}
                                                     let chName = ppListSep "" "" "_" [pp name_, _lhsIppNt, _lhsIppProd]
                                                     in  pp name_ >|< " <- at ch_" >|< chName
                                                     {-# LINE 531 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule13 #-}
   {-# LINE 489 "src-ag/AG2AspectAG.ag" #-}
   rule13 = \ name_ tp_ ->
                                                    {-# LINE 489 "src-ag/AG2AspectAG.ag" #-}
                                                    [ (name_, removeDeforested tp_ ) ]
                                                    {-# LINE 537 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule14 #-}
   {-# LINE 827 "src-ag/AG2AspectAG.ag" #-}
   rule14 = \ _chLabel kind_ name_ tp_ ->
                                              {-# LINE 827 "src-ag/AG2AspectAG.ag" #-}
                                              let
                                                   semC   = if (isNonterminal tp_)
                                                             then "sem_" >|< ppShow tp_ >|<  " _" >|< name_
                                                             else "sem_Lit _" >|< name_
                                              in   case kind_ of
                                                        ChildSyntax ->  [(name_, (  _chLabel     >|< " .=. (" >|< semC >|< ") .*. "
                                                                                ,  _chLabel     >|< " .=. _" >|< name_ >|< " .*. "))]
                                                        _           ->  []
                                              {-# LINE 550 "src-generated/AG2AspectAG.hs" #-}

-- Children ----------------------------------------------------
-- wrapper
data Inh_Children  = Inh_Children { ext_Inh_Children :: (Maybe String), inhMap_Inh_Children :: (Map Identifier Attributes), inhNoGroup_Inh_Children :: ([String]), newAtts_Inh_Children :: ( Attributes ), o_noGroup_Inh_Children :: ([String]), o_rename_Inh_Children :: (Bool), ppNt_Inh_Children :: (PP_Doc), ppProd_Inh_Children :: (PP_Doc), synMap_Inh_Children :: (Map Identifier Attributes), synNoGroup_Inh_Children :: ([String]) }
data Syn_Children  = Syn_Children { idCL_Syn_Children :: ([(Identifier,Type)]), ppCSF_Syn_Children :: ([(Identifier,(PP_Doc,PP_Doc))]), ppDL_Syn_Children :: ([PP_Doc]), ppL_Syn_Children :: (PP_Doc), ppLI_Syn_Children :: ([PP_Doc]), ppR_Syn_Children :: (PP_Doc), prdInh_Syn_Children :: (Attributes) }
{-# INLINABLE wrap_Children #-}
wrap_Children :: T_Children  -> Inh_Children  -> (Syn_Children )
wrap_Children (T_Children act) (Inh_Children _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg4 = T_Children_vIn4 _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup
        (T_Children_vOut4 _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh) <- return (inv_Children_s5 sem arg4)
        return (Syn_Children _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh)
   )

-- cata
{-# NOINLINE sem_Children #-}
sem_Children :: Children  -> T_Children 
sem_Children list = Prelude.foldr sem_Children_Cons sem_Children_Nil (Prelude.map sem_Child list)

-- semantic domain
newtype T_Children  = T_Children {
                                 attach_T_Children :: Identity (T_Children_s5 )
                                 }
newtype T_Children_s5  = C_Children_s5 {
                                       inv_Children_s5 :: (T_Children_v4 )
                                       }
data T_Children_s6  = C_Children_s6
type T_Children_v4  = (T_Children_vIn4 ) -> (T_Children_vOut4 )
data T_Children_vIn4  = T_Children_vIn4 (Maybe String) (Map Identifier Attributes) ([String]) ( Attributes ) ([String]) (Bool) (PP_Doc) (PP_Doc) (Map Identifier Attributes) ([String])
data T_Children_vOut4  = T_Children_vOut4 ([(Identifier,Type)]) ([(Identifier,(PP_Doc,PP_Doc))]) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (Attributes)
{-# NOINLINE sem_Children_Cons #-}
sem_Children_Cons :: T_Child  -> T_Children  -> T_Children 
sem_Children_Cons arg_hd_ arg_tl_ = T_Children (return st5) where
   {-# NOINLINE st5 #-}
   st5 = let
      v4 :: T_Children_v4 
      v4 = \ (T_Children_vIn4 _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup) -> ( let
         _hdX2 = Control.Monad.Identity.runIdentity (attach_T_Child (arg_hd_))
         _tlX5 = Control.Monad.Identity.runIdentity (attach_T_Children (arg_tl_))
         (T_Child_vOut1 _hdIidCL _hdIppCSF _hdIppDL _hdIppL _hdIppLI _hdIppR _hdIprdInh) = inv_Child_s2 _hdX2 (T_Child_vIn1 _hdOext _hdOinhMap _hdOinhNoGroup _hdOnewAtts _hdOo_noGroup _hdOo_rename _hdOppNt _hdOppProd _hdOsynMap _hdOsynNoGroup)
         (T_Children_vOut4 _tlIidCL _tlIppCSF _tlIppDL _tlIppL _tlIppLI _tlIppR _tlIprdInh) = inv_Children_s5 _tlX5 (T_Children_vIn4 _tlOext _tlOinhMap _tlOinhNoGroup _tlOnewAtts _tlOo_noGroup _tlOo_rename _tlOppNt _tlOppProd _tlOsynMap _tlOsynNoGroup)
         _lhsOppDL :: [PP_Doc]
         _lhsOppDL = rule15 _hdIppDL _tlIppDL
         _lhsOidCL :: [(Identifier,Type)]
         _lhsOidCL = rule16 _hdIidCL _tlIidCL
         _lhsOppCSF :: [(Identifier,(PP_Doc,PP_Doc))]
         _lhsOppCSF = rule17 _hdIppCSF _tlIppCSF
         _lhsOppL :: PP_Doc
         _lhsOppL = rule18 _hdIppL _tlIppL
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule19 _hdIppLI _tlIppLI
         _lhsOppR :: PP_Doc
         _lhsOppR = rule20 _hdIppR _tlIppR
         _lhsOprdInh :: Attributes
         _lhsOprdInh = rule21 _hdIprdInh _tlIprdInh
         _hdOext = rule22 _lhsIext
         _hdOinhMap = rule23 _lhsIinhMap
         _hdOinhNoGroup = rule24 _lhsIinhNoGroup
         _hdOnewAtts = rule25 _lhsInewAtts
         _hdOo_noGroup = rule26 _lhsIo_noGroup
         _hdOo_rename = rule27 _lhsIo_rename
         _hdOppNt = rule28 _lhsIppNt
         _hdOppProd = rule29 _lhsIppProd
         _hdOsynMap = rule30 _lhsIsynMap
         _hdOsynNoGroup = rule31 _lhsIsynNoGroup
         _tlOext = rule32 _lhsIext
         _tlOinhMap = rule33 _lhsIinhMap
         _tlOinhNoGroup = rule34 _lhsIinhNoGroup
         _tlOnewAtts = rule35 _lhsInewAtts
         _tlOo_noGroup = rule36 _lhsIo_noGroup
         _tlOo_rename = rule37 _lhsIo_rename
         _tlOppNt = rule38 _lhsIppNt
         _tlOppProd = rule39 _lhsIppProd
         _tlOsynMap = rule40 _lhsIsynMap
         _tlOsynNoGroup = rule41 _lhsIsynNoGroup
         __result_ = T_Children_vOut4 _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh
         in __result_ )
     in C_Children_s5 v4
   {-# INLINE rule15 #-}
   {-# LINE 238 "src-ag/AG2AspectAG.ag" #-}
   rule15 = \ ((_hdIppDL) :: [PP_Doc]) ((_tlIppDL) :: [PP_Doc]) ->
                                                                                  {-# LINE 238 "src-ag/AG2AspectAG.ag" #-}
                                                                                  _hdIppDL ++ _tlIppDL
                                                                                  {-# LINE 635 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule16 #-}
   rule16 = \ ((_hdIidCL) :: [(Identifier,Type)]) ((_tlIidCL) :: [(Identifier,Type)]) ->
     _hdIidCL ++ _tlIidCL
   {-# INLINE rule17 #-}
   rule17 = \ ((_hdIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) ((_tlIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) ->
     _hdIppCSF ++ _tlIppCSF
   {-# INLINE rule18 #-}
   rule18 = \ ((_hdIppL) :: PP_Doc) ((_tlIppL) :: PP_Doc) ->
     _hdIppL >-< _tlIppL
   {-# INLINE rule19 #-}
   rule19 = \ ((_hdIppLI) :: [PP_Doc]) ((_tlIppLI) :: [PP_Doc]) ->
     _hdIppLI ++ _tlIppLI
   {-# INLINE rule20 #-}
   rule20 = \ ((_hdIppR) :: PP_Doc) ((_tlIppR) :: PP_Doc) ->
     _hdIppR >-< _tlIppR
   {-# INLINE rule21 #-}
   rule21 = \ ((_hdIprdInh) :: Attributes) ((_tlIprdInh) :: Attributes) ->
     _hdIprdInh `Map.union` _tlIprdInh
   {-# INLINE rule22 #-}
   rule22 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule23 #-}
   rule23 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule24 #-}
   rule24 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule25 #-}
   rule25 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule26 #-}
   rule26 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule27 #-}
   rule27 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule28 #-}
   rule28 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule29 #-}
   rule29 = \ ((_lhsIppProd) :: PP_Doc) ->
     _lhsIppProd
   {-# INLINE rule30 #-}
   rule30 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule31 #-}
   rule31 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
   {-# INLINE rule32 #-}
   rule32 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule33 #-}
   rule33 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule34 #-}
   rule34 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule35 #-}
   rule35 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule36 #-}
   rule36 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule37 #-}
   rule37 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule38 #-}
   rule38 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule39 #-}
   rule39 = \ ((_lhsIppProd) :: PP_Doc) ->
     _lhsIppProd
   {-# INLINE rule40 #-}
   rule40 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule41 #-}
   rule41 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
{-# NOINLINE sem_Children_Nil #-}
sem_Children_Nil ::  T_Children 
sem_Children_Nil  = T_Children (return st5) where
   {-# NOINLINE st5 #-}
   st5 = let
      v4 :: T_Children_v4 
      v4 = \ (T_Children_vIn4 _lhsIext _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIppProd _lhsIsynMap _lhsIsynNoGroup) -> ( let
         _lhsOppDL :: [PP_Doc]
         _lhsOppDL = rule42  ()
         _lhsOidCL :: [(Identifier,Type)]
         _lhsOidCL = rule43  ()
         _lhsOppCSF :: [(Identifier,(PP_Doc,PP_Doc))]
         _lhsOppCSF = rule44  ()
         _lhsOppL :: PP_Doc
         _lhsOppL = rule45  ()
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule46  ()
         _lhsOppR :: PP_Doc
         _lhsOppR = rule47  ()
         _lhsOprdInh :: Attributes
         _lhsOprdInh = rule48  ()
         __result_ = T_Children_vOut4 _lhsOidCL _lhsOppCSF _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOprdInh
         in __result_ )
     in C_Children_s5 v4
   {-# INLINE rule42 #-}
   {-# LINE 239 "src-ag/AG2AspectAG.ag" #-}
   rule42 = \  (_ :: ()) ->
                                                                                  {-# LINE 239 "src-ag/AG2AspectAG.ag" #-}
                                                                                  []
                                                                                  {-# LINE 743 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule43 #-}
   rule43 = \  (_ :: ()) ->
     []
   {-# INLINE rule44 #-}
   rule44 = \  (_ :: ()) ->
     []
   {-# INLINE rule45 #-}
   rule45 = \  (_ :: ()) ->
     empty
   {-# INLINE rule46 #-}
   rule46 = \  (_ :: ()) ->
     []
   {-# INLINE rule47 #-}
   rule47 = \  (_ :: ()) ->
     empty
   {-# INLINE rule48 #-}
   rule48 = \  (_ :: ()) ->
     Map.empty

-- Expression --------------------------------------------------
-- wrapper
data Inh_Expression  = Inh_Expression { ppNt_Inh_Expression :: (PP_Doc), ppProd_Inh_Expression :: (PP_Doc) }
data Syn_Expression  = Syn_Expression { ppRE_Syn_Expression :: ([String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression  -> Inh_Expression  -> (Syn_Expression )
wrap_Expression (T_Expression act) (Inh_Expression _lhsIppNt _lhsIppProd) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg7 = T_Expression_vIn7 _lhsIppNt _lhsIppProd
        (T_Expression_vOut7 _lhsOppRE) <- return (inv_Expression_s8 sem arg7)
        return (Syn_Expression _lhsOppRE)
   )

-- cata
{-# INLINE sem_Expression #-}
sem_Expression :: Expression  -> T_Expression 
sem_Expression ( Expression pos_ tks_ ) = sem_Expression_Expression pos_ tks_

-- semantic domain
newtype T_Expression  = T_Expression {
                                     attach_T_Expression :: Identity (T_Expression_s8 )
                                     }
newtype T_Expression_s8  = C_Expression_s8 {
                                           inv_Expression_s8 :: (T_Expression_v7 )
                                           }
data T_Expression_s9  = C_Expression_s9
type T_Expression_v7  = (T_Expression_vIn7 ) -> (T_Expression_vOut7 )
data T_Expression_vIn7  = T_Expression_vIn7 (PP_Doc) (PP_Doc)
data T_Expression_vOut7  = T_Expression_vOut7 ([String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc)
{-# NOINLINE sem_Expression_Expression #-}
sem_Expression_Expression :: (Pos) -> ([HsToken]) -> T_Expression 
sem_Expression_Expression _ arg_tks_ = T_Expression (return st8) where
   {-# NOINLINE st8 #-}
   st8 = let
      v7 :: T_Expression_v7 
      v7 = \ (T_Expression_vIn7 _lhsIppNt _lhsIppProd) -> ( let
         _lhsOppRE :: [String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc
         _lhsOppRE = rule49 _lhsIppNt _lhsIppProd arg_tks_
         __result_ = T_Expression_vOut7 _lhsOppRE
         in __result_ )
     in C_Expression_s8 v7
   {-# INLINE rule49 #-}
   {-# LINE 484 "src-ag/AG2AspectAG.ag" #-}
   rule49 = \ ((_lhsIppNt) :: PP_Doc) ((_lhsIppProd) :: PP_Doc) tks_ ->
                                                      {-# LINE 484 "src-ag/AG2AspectAG.ag" #-}
                                                      rhsRule _lhsIppNt _lhsIppProd tks_
                                                      {-# LINE 810 "src-generated/AG2AspectAG.hs" #-}

-- Grammar -----------------------------------------------------
-- wrapper
data Inh_Grammar  = Inh_Grammar { agi_Inh_Grammar :: ((Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))), ext_Inh_Grammar :: (Maybe String), options_Inh_Grammar :: (Options) }
data Syn_Grammar  = Syn_Grammar { imp_Syn_Grammar :: (PP_Doc), pp_Syn_Grammar :: (PP_Doc) }
{-# INLINABLE wrap_Grammar #-}
wrap_Grammar :: T_Grammar  -> Inh_Grammar  -> (Syn_Grammar )
wrap_Grammar (T_Grammar act) (Inh_Grammar _lhsIagi _lhsIext _lhsIoptions) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg10 = T_Grammar_vIn10 _lhsIagi _lhsIext _lhsIoptions
        (T_Grammar_vOut10 _lhsOimp _lhsOpp) <- return (inv_Grammar_s11 sem arg10)
        return (Syn_Grammar _lhsOimp _lhsOpp)
   )

-- cata
{-# INLINE sem_Grammar #-}
sem_Grammar :: Grammar  -> T_Grammar 
sem_Grammar ( Grammar typeSyns_ useMap_ derivings_ wrappers_ nonts_ pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_ ) = sem_Grammar_Grammar typeSyns_ useMap_ derivings_ wrappers_ ( sem_Nonterminals nonts_ ) pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_

-- semantic domain
newtype T_Grammar  = T_Grammar {
                               attach_T_Grammar :: Identity (T_Grammar_s11 )
                               }
newtype T_Grammar_s11  = C_Grammar_s11 {
                                       inv_Grammar_s11 :: (T_Grammar_v10 )
                                       }
data T_Grammar_s12  = C_Grammar_s12
type T_Grammar_v10  = (T_Grammar_vIn10 ) -> (T_Grammar_vOut10 )
data T_Grammar_vIn10  = T_Grammar_vIn10 ((Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) (Maybe String) (Options)
data T_Grammar_vOut10  = T_Grammar_vOut10 (PP_Doc) (PP_Doc)
{-# NOINLINE sem_Grammar_Grammar #-}
sem_Grammar_Grammar :: (TypeSyns) -> (UseMap) -> (Derivings) -> (Set NontermIdent) -> T_Nonterminals  -> (PragmaMap) -> (AttrOrderMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (UniqueMap) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) -> T_Grammar 
sem_Grammar_Grammar arg_typeSyns_ _ arg_derivings_ _ arg_nonts_ _ _ _ _ _ _ _ _ _ = T_Grammar (return st11) where
   {-# NOINLINE st11 #-}
   st11 = let
      v10 :: T_Grammar_v10 
      v10 = \ (T_Grammar_vIn10 _lhsIagi _lhsIext _lhsIoptions) -> ( let
         _nontsX26 = Control.Monad.Identity.runIdentity (attach_T_Nonterminals (arg_nonts_))
         (T_Nonterminals_vOut25 _nontsIextendedNTs _nontsIinhMap' _nontsIppA _nontsIppAI _nontsIppCata _nontsIppD _nontsIppDI _nontsIppL _nontsIppLI _nontsIppNtL _nontsIppR _nontsIppSF _nontsIppW _nontsIsynMap') = inv_Nonterminals_s26 _nontsX26 (T_Nonterminals_vIn25 _nontsOderivs _nontsOext _nontsOinhMap _nontsOnewAtts _nontsOnewNTs _nontsOnewProds _nontsOo_noGroup _nontsOo_rename _nontsOsynMap _nontsOtSyns)
         _nontsOinhMap = rule50 _nontsIinhMap'
         _nontsOsynMap = rule51 _nontsIsynMap'
         _nontsOo_rename = rule52 _lhsIoptions
         _o_noGroup = rule53 _lhsIoptions
         _nontsOo_noGroup = rule54 _o_noGroup
         _newAtts = rule55 _lhsIagi
         _nontsOnewAtts = rule56 _newAtts
         _newProds = rule57 _lhsIagi
         _nontsOnewProds = rule58 _newProds
         _nontsOnewNTs = rule59 _lhsIagi _nontsIextendedNTs
         _lhsOimp :: PP_Doc
         _lhsOimp = rule60 _lhsIext _nontsIppDI _nontsIppLI _ppAI _ppANT
         _lhsOpp :: PP_Doc
         _lhsOpp = rule61 _lhsIoptions _nontsIppCata _nontsIppD _nontsIppL _nontsIppSF _nontsIppW _ppA _ppR
         _nontsOderivs = rule62 arg_derivings_
         _nontsOtSyns = rule63 arg_typeSyns_
         _ppA = rule64 _lhsIext _newAtts _nontsIppA _o_noGroup
         _ppAI = rule65 _lhsIext _newAtts _nontsIppAI _o_noGroup
         _ppANT = rule66 _newAtts _o_noGroup
         _ppNtL = rule67 _nontsIppNtL
         _ppR = rule68 _newAtts _nontsIppR _o_noGroup _ppNtL
         _nontsOext = rule69 _lhsIext
         __result_ = T_Grammar_vOut10 _lhsOimp _lhsOpp
         in __result_ )
     in C_Grammar_s11 v10
   {-# INLINE rule50 #-}
   {-# LINE 15 "src-ag/DistChildAttr.ag" #-}
   rule50 = \ ((_nontsIinhMap') :: Map Identifier Attributes) ->
                             {-# LINE 15 "src-ag/DistChildAttr.ag" #-}
                             _nontsIinhMap'
                             {-# LINE 881 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule51 #-}
   {-# LINE 16 "src-ag/DistChildAttr.ag" #-}
   rule51 = \ ((_nontsIsynMap') :: Map Identifier Attributes) ->
                             {-# LINE 16 "src-ag/DistChildAttr.ag" #-}
                             _nontsIsynMap'
                             {-# LINE 887 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule52 #-}
   {-# LINE 43 "src-ag/AG2AspectAG.ag" #-}
   rule52 = \ ((_lhsIoptions) :: Options) ->
                                   {-# LINE 43 "src-ag/AG2AspectAG.ag" #-}
                                   rename    _lhsIoptions
                                   {-# LINE 893 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule53 #-}
   {-# LINE 47 "src-ag/AG2AspectAG.ag" #-}
   rule53 = \ ((_lhsIoptions) :: Options) ->
                                   {-# LINE 47 "src-ag/AG2AspectAG.ag" #-}
                                   sort $ noGroup    _lhsIoptions
                                   {-# LINE 899 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule54 #-}
   {-# LINE 48 "src-ag/AG2AspectAG.ag" #-}
   rule54 = \ _o_noGroup ->
                                   {-# LINE 48 "src-ag/AG2AspectAG.ag" #-}
                                   _o_noGroup
                                   {-# LINE 905 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule55 #-}
   {-# LINE 80 "src-ag/AG2AspectAG.ag" #-}
   rule55 = \ ((_lhsIagi) :: (Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) ->
                                          {-# LINE 80 "src-ag/AG2AspectAG.ag" #-}
                                          case _lhsIagi of
                                                  (_,_,atts) -> ( Map.unions . (\(a,b) -> a++b) . unzip . Map.elems) atts
                                          {-# LINE 912 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule56 #-}
   {-# LINE 82 "src-ag/AG2AspectAG.ag" #-}
   rule56 = \ _newAtts ->
                                          {-# LINE 82 "src-ag/AG2AspectAG.ag" #-}
                                          _newAtts
                                          {-# LINE 918 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule57 #-}
   {-# LINE 88 "src-ag/AG2AspectAG.ag" #-}
   rule57 = \ ((_lhsIagi) :: (Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) ->
                                           {-# LINE 88 "src-ag/AG2AspectAG.ag" #-}
                                           case _lhsIagi of
                                                  (_,prods,_) -> prods
                                           {-# LINE 925 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule58 #-}
   {-# LINE 90 "src-ag/AG2AspectAG.ag" #-}
   rule58 = \ _newProds ->
                                           {-# LINE 90 "src-ag/AG2AspectAG.ag" #-}
                                           _newProds
                                           {-# LINE 931 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule59 #-}
   {-# LINE 112 "src-ag/AG2AspectAG.ag" #-}
   rule59 = \ ((_lhsIagi) :: (Set NontermIdent, DataTypes, Map NontermIdent (Attributes, Attributes))) ((_nontsIextendedNTs) :: Set NontermIdent) ->
                                          {-# LINE 112 "src-ag/AG2AspectAG.ag" #-}
                                          case _lhsIagi of
                                                  (newNTs,_,_) -> Set.difference newNTs _nontsIextendedNTs
                                          {-# LINE 938 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule60 #-}
   {-# LINE 127 "src-ag/AG2AspectAG.ag" #-}
   rule60 = \ ((_lhsIext) :: Maybe String) ((_nontsIppDI) :: [PP_Doc]) ((_nontsIppLI) :: [PP_Doc]) _ppAI _ppANT ->
                                                     {-# LINE 127 "src-ag/AG2AspectAG.ag" #-}
                                                     "import Language.Grammars.AspectAG" >-<
                                                     "import Language.Grammars.AspectAG.Derive" >-<
                                                     "import Data.HList.Label4" >-<
                                                     "import Data.HList.TypeEqGeneric1" >-<
                                                     "import Data.HList.TypeCastGeneric1" >-<
                                                     maybe empty ("import qualified" >#<) _lhsIext >-<
                                                     maybe empty (\ext -> "import" >#< ext >#< ppListSep "(" ")" "," (_nontsIppDI ++ _nontsIppLI ++ _ppAI     ++ _ppANT    )) _lhsIext
                                                     {-# LINE 950 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule61 #-}
   {-# LINE 140 "src-ag/AG2AspectAG.ag" #-}
   rule61 = \ ((_lhsIoptions) :: Options) ((_nontsIppCata) :: PP_Doc) ((_nontsIppD) :: PP_Doc) ((_nontsIppL) :: PP_Doc) ((_nontsIppSF) :: PP_Doc) ((_nontsIppW) :: PP_Doc) _ppA _ppR ->
                                                     {-# LINE 140 "src-ag/AG2AspectAG.ag" #-}
                                                     (if dataTypes _lhsIoptions
                                                     then  "-- datatypes"               >-< _nontsIppD >-<
                                                           "-- labels"                  >-< _nontsIppL
                                                     else  empty)
                                                     >-<
                                                     (if folds _lhsIoptions
                                                     then  "-- attributes"              >-< _ppA     >-<
                                                           "-- rules"                   >-< _ppR     >-<
                                                           "-- catas"                   >-< _nontsIppCata
                                                     else  empty)
                                                     >-<
                                                     (if semfuns _lhsIoptions
                                                     then  "-- semantic functions"      >-< _nontsIppSF
                                                     else  empty)
                                                     >-<
                                                     (if wrappers _lhsIoptions
                                                     then  "-- wrappers"    >-< _nontsIppW
                                                     else  empty)
                                                     {-# LINE 973 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule62 #-}
   {-# LINE 202 "src-ag/AG2AspectAG.ag" #-}
   rule62 = \ derivings_ ->
                                                     {-# LINE 202 "src-ag/AG2AspectAG.ag" #-}
                                                     derivings_
                                                     {-# LINE 979 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule63 #-}
   {-# LINE 251 "src-ag/AG2AspectAG.ag" #-}
   rule63 = \ typeSyns_ ->
                                                                                  {-# LINE 251 "src-ag/AG2AspectAG.ag" #-}
                                                                                  typeSyns_
                                                                                  {-# LINE 985 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule64 #-}
   {-# LINE 300 "src-ag/AG2AspectAG.ag" #-}
   rule64 = \ ((_lhsIext) :: Maybe String) _newAtts ((_nontsIppA) :: PP_Doc) _o_noGroup ->
                                                     {-# LINE 300 "src-ag/AG2AspectAG.ag" #-}
                                                     vlist (map defAtt (filterAtts _newAtts     _o_noGroup    )) >-<
                                                     defAtt "loc" >-<
                                                     (case _lhsIext of
                                                       Nothing    ->  defAtt "inh" >-< defAtt "syn"
                                                       otherwise  ->  empty) >-<
                                                     _nontsIppA
                                                     {-# LINE 996 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule65 #-}
   {-# LINE 308 "src-ag/AG2AspectAG.ag" #-}
   rule65 = \ ((_lhsIext) :: Maybe String) _newAtts ((_nontsIppAI) :: [PP_Doc]) _o_noGroup ->
                                                  {-# LINE 308 "src-ag/AG2AspectAG.ag" #-}
                                                  let atts =  filterNotAtts _newAtts     _o_noGroup
                                                  in  (foldr (\a as -> attName a : as) [] atts) ++
                                                      (foldr (\a as -> attTName a : as) [] atts) ++
                                                      (case _lhsIext of
                                                        Nothing    ->  []
                                                        otherwise  ->  [ attName "inh", attName "syn", attTName "inh", attTName "syn" ]) ++
                                                      _nontsIppAI
                                                  {-# LINE 1008 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule66 #-}
   {-# LINE 318 "src-ag/AG2AspectAG.ag" #-}
   rule66 = \ _newAtts _o_noGroup ->
                                                  {-# LINE 318 "src-ag/AG2AspectAG.ag" #-}
                                                  let atts =  filterNotAtts _newAtts     _o_noGroup
                                                  in  (foldr (\a as -> ("nts_" >|< a) : as) [] atts)
                                                  {-# LINE 1015 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule67 #-}
   {-# LINE 392 "src-ag/AG2AspectAG.ag" #-}
   rule67 = \ ((_nontsIppNtL) :: [(PP_Doc, Attributes)]) ->
                                                     {-# LINE 392 "src-ag/AG2AspectAG.ag" #-}
                                                     _nontsIppNtL
                                                     {-# LINE 1021 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule68 #-}
   {-# LINE 393 "src-ag/AG2AspectAG.ag" #-}
   rule68 = \ _newAtts ((_nontsIppR) :: PP_Doc) _o_noGroup _ppNtL ->
                                                     {-# LINE 393 "src-ag/AG2AspectAG.ag" #-}
                                                     ntsList "group" _ppNtL      >-<
                                                     vlist (map (\att -> ntsList att (filterNts att _ppNtL    )) (filterAtts _newAtts _o_noGroup    ))  >-<
                                                     _nontsIppR
                                                     {-# LINE 1029 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule69 #-}
   rule69 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext

-- HsToken -----------------------------------------------------
-- wrapper
data Inh_HsToken  = Inh_HsToken {  }
data Syn_HsToken  = Syn_HsToken {  }
{-# INLINABLE wrap_HsToken #-}
wrap_HsToken :: T_HsToken  -> Inh_HsToken  -> (Syn_HsToken )
wrap_HsToken (T_HsToken act) (Inh_HsToken ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg13 = T_HsToken_vIn13 
        (T_HsToken_vOut13 ) <- return (inv_HsToken_s14 sem arg13)
        return (Syn_HsToken )
   )

-- cata
{-# NOINLINE sem_HsToken #-}
sem_HsToken :: HsToken  -> T_HsToken 
sem_HsToken ( AGLocal var_ pos_ rdesc_ ) = sem_HsToken_AGLocal var_ pos_ rdesc_
sem_HsToken ( AGField field_ attr_ pos_ rdesc_ ) = sem_HsToken_AGField field_ attr_ pos_ rdesc_
sem_HsToken ( HsToken value_ pos_ ) = sem_HsToken_HsToken value_ pos_
sem_HsToken ( CharToken value_ pos_ ) = sem_HsToken_CharToken value_ pos_
sem_HsToken ( StrToken value_ pos_ ) = sem_HsToken_StrToken value_ pos_
sem_HsToken ( Err mesg_ pos_ ) = sem_HsToken_Err mesg_ pos_

-- semantic domain
newtype T_HsToken  = T_HsToken {
                               attach_T_HsToken :: Identity (T_HsToken_s14 )
                               }
newtype T_HsToken_s14  = C_HsToken_s14 {
                                       inv_HsToken_s14 :: (T_HsToken_v13 )
                                       }
data T_HsToken_s15  = C_HsToken_s15
type T_HsToken_v13  = (T_HsToken_vIn13 ) -> (T_HsToken_vOut13 )
data T_HsToken_vIn13  = T_HsToken_vIn13 
data T_HsToken_vOut13  = T_HsToken_vOut13 
{-# NOINLINE sem_HsToken_AGLocal #-}
sem_HsToken_AGLocal :: (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGLocal _ _ _ = T_HsToken (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_HsToken_v13 
      v13 = \ (T_HsToken_vIn13 ) -> ( let
         __result_ = T_HsToken_vOut13 
         in __result_ )
     in C_HsToken_s14 v13
{-# NOINLINE sem_HsToken_AGField #-}
sem_HsToken_AGField :: (Identifier) -> (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGField _ _ _ _ = T_HsToken (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_HsToken_v13 
      v13 = \ (T_HsToken_vIn13 ) -> ( let
         __result_ = T_HsToken_vOut13 
         in __result_ )
     in C_HsToken_s14 v13
{-# NOINLINE sem_HsToken_HsToken #-}
sem_HsToken_HsToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_HsToken _ _ = T_HsToken (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_HsToken_v13 
      v13 = \ (T_HsToken_vIn13 ) -> ( let
         __result_ = T_HsToken_vOut13 
         in __result_ )
     in C_HsToken_s14 v13
{-# NOINLINE sem_HsToken_CharToken #-}
sem_HsToken_CharToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_CharToken _ _ = T_HsToken (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_HsToken_v13 
      v13 = \ (T_HsToken_vIn13 ) -> ( let
         __result_ = T_HsToken_vOut13 
         in __result_ )
     in C_HsToken_s14 v13
{-# NOINLINE sem_HsToken_StrToken #-}
sem_HsToken_StrToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_StrToken _ _ = T_HsToken (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_HsToken_v13 
      v13 = \ (T_HsToken_vIn13 ) -> ( let
         __result_ = T_HsToken_vOut13 
         in __result_ )
     in C_HsToken_s14 v13
{-# NOINLINE sem_HsToken_Err #-}
sem_HsToken_Err :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_Err _ _ = T_HsToken (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_HsToken_v13 
      v13 = \ (T_HsToken_vIn13 ) -> ( let
         __result_ = T_HsToken_vOut13 
         in __result_ )
     in C_HsToken_s14 v13

-- HsTokens ----------------------------------------------------
-- wrapper
data Inh_HsTokens  = Inh_HsTokens {  }
data Syn_HsTokens  = Syn_HsTokens {  }
{-# INLINABLE wrap_HsTokens #-}
wrap_HsTokens :: T_HsTokens  -> Inh_HsTokens  -> (Syn_HsTokens )
wrap_HsTokens (T_HsTokens act) (Inh_HsTokens ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg16 = T_HsTokens_vIn16 
        (T_HsTokens_vOut16 ) <- return (inv_HsTokens_s17 sem arg16)
        return (Syn_HsTokens )
   )

-- cata
{-# NOINLINE sem_HsTokens #-}
sem_HsTokens :: HsTokens  -> T_HsTokens 
sem_HsTokens list = Prelude.foldr sem_HsTokens_Cons sem_HsTokens_Nil (Prelude.map sem_HsToken list)

-- semantic domain
newtype T_HsTokens  = T_HsTokens {
                                 attach_T_HsTokens :: Identity (T_HsTokens_s17 )
                                 }
newtype T_HsTokens_s17  = C_HsTokens_s17 {
                                         inv_HsTokens_s17 :: (T_HsTokens_v16 )
                                         }
data T_HsTokens_s18  = C_HsTokens_s18
type T_HsTokens_v16  = (T_HsTokens_vIn16 ) -> (T_HsTokens_vOut16 )
data T_HsTokens_vIn16  = T_HsTokens_vIn16 
data T_HsTokens_vOut16  = T_HsTokens_vOut16 
{-# NOINLINE sem_HsTokens_Cons #-}
sem_HsTokens_Cons :: T_HsToken  -> T_HsTokens  -> T_HsTokens 
sem_HsTokens_Cons arg_hd_ arg_tl_ = T_HsTokens (return st17) where
   {-# NOINLINE st17 #-}
   st17 = let
      v16 :: T_HsTokens_v16 
      v16 = \ (T_HsTokens_vIn16 ) -> ( let
         _hdX14 = Control.Monad.Identity.runIdentity (attach_T_HsToken (arg_hd_))
         _tlX17 = Control.Monad.Identity.runIdentity (attach_T_HsTokens (arg_tl_))
         (T_HsToken_vOut13 ) = inv_HsToken_s14 _hdX14 (T_HsToken_vIn13 )
         (T_HsTokens_vOut16 ) = inv_HsTokens_s17 _tlX17 (T_HsTokens_vIn16 )
         __result_ = T_HsTokens_vOut16 
         in __result_ )
     in C_HsTokens_s17 v16
{-# NOINLINE sem_HsTokens_Nil #-}
sem_HsTokens_Nil ::  T_HsTokens 
sem_HsTokens_Nil  = T_HsTokens (return st17) where
   {-# NOINLINE st17 #-}
   st17 = let
      v16 :: T_HsTokens_v16 
      v16 = \ (T_HsTokens_vIn16 ) -> ( let
         __result_ = T_HsTokens_vOut16 
         in __result_ )
     in C_HsTokens_s17 v16

-- HsTokensRoot ------------------------------------------------
-- wrapper
data Inh_HsTokensRoot  = Inh_HsTokensRoot {  }
data Syn_HsTokensRoot  = Syn_HsTokensRoot {  }
{-# INLINABLE wrap_HsTokensRoot #-}
wrap_HsTokensRoot :: T_HsTokensRoot  -> Inh_HsTokensRoot  -> (Syn_HsTokensRoot )
wrap_HsTokensRoot (T_HsTokensRoot act) (Inh_HsTokensRoot ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg19 = T_HsTokensRoot_vIn19 
        (T_HsTokensRoot_vOut19 ) <- return (inv_HsTokensRoot_s20 sem arg19)
        return (Syn_HsTokensRoot )
   )

-- cata
{-# INLINE sem_HsTokensRoot #-}
sem_HsTokensRoot :: HsTokensRoot  -> T_HsTokensRoot 
sem_HsTokensRoot ( HsTokensRoot tokens_ ) = sem_HsTokensRoot_HsTokensRoot ( sem_HsTokens tokens_ )

-- semantic domain
newtype T_HsTokensRoot  = T_HsTokensRoot {
                                         attach_T_HsTokensRoot :: Identity (T_HsTokensRoot_s20 )
                                         }
newtype T_HsTokensRoot_s20  = C_HsTokensRoot_s20 {
                                                 inv_HsTokensRoot_s20 :: (T_HsTokensRoot_v19 )
                                                 }
data T_HsTokensRoot_s21  = C_HsTokensRoot_s21
type T_HsTokensRoot_v19  = (T_HsTokensRoot_vIn19 ) -> (T_HsTokensRoot_vOut19 )
data T_HsTokensRoot_vIn19  = T_HsTokensRoot_vIn19 
data T_HsTokensRoot_vOut19  = T_HsTokensRoot_vOut19 
{-# NOINLINE sem_HsTokensRoot_HsTokensRoot #-}
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens  -> T_HsTokensRoot 
sem_HsTokensRoot_HsTokensRoot arg_tokens_ = T_HsTokensRoot (return st20) where
   {-# NOINLINE st20 #-}
   st20 = let
      v19 :: T_HsTokensRoot_v19 
      v19 = \ (T_HsTokensRoot_vIn19 ) -> ( let
         _tokensX17 = Control.Monad.Identity.runIdentity (attach_T_HsTokens (arg_tokens_))
         (T_HsTokens_vOut16 ) = inv_HsTokens_s17 _tokensX17 (T_HsTokens_vIn16 )
         __result_ = T_HsTokensRoot_vOut19 
         in __result_ )
     in C_HsTokensRoot_s20 v19

-- Nonterminal -------------------------------------------------
-- wrapper
data Inh_Nonterminal  = Inh_Nonterminal { derivs_Inh_Nonterminal :: (Derivings), ext_Inh_Nonterminal :: (Maybe String), inhMap_Inh_Nonterminal :: (Map Identifier Attributes), newAtts_Inh_Nonterminal :: ( Attributes ), newNTs_Inh_Nonterminal :: (Set NontermIdent), newProds_Inh_Nonterminal :: ( DataTypes ), o_noGroup_Inh_Nonterminal :: ([String]), o_rename_Inh_Nonterminal :: (Bool), synMap_Inh_Nonterminal :: (Map Identifier Attributes), tSyns_Inh_Nonterminal :: (TypeSyns) }
data Syn_Nonterminal  = Syn_Nonterminal { extendedNTs_Syn_Nonterminal :: (Set NontermIdent), inhMap'_Syn_Nonterminal :: (Map Identifier Attributes), ppA_Syn_Nonterminal :: (PP_Doc), ppAI_Syn_Nonterminal :: ([PP_Doc]), ppCata_Syn_Nonterminal :: (PP_Doc), ppD_Syn_Nonterminal :: (PP_Doc), ppDI_Syn_Nonterminal :: ([PP_Doc]), ppL_Syn_Nonterminal :: (PP_Doc), ppLI_Syn_Nonterminal :: ([PP_Doc]), ppNtL_Syn_Nonterminal :: ([(PP_Doc, Attributes)]), ppR_Syn_Nonterminal :: (PP_Doc), ppSF_Syn_Nonterminal :: (PP_Doc), ppW_Syn_Nonterminal :: (PP_Doc), synMap'_Syn_Nonterminal :: (Map Identifier Attributes) }
{-# INLINABLE wrap_Nonterminal #-}
wrap_Nonterminal :: T_Nonterminal  -> Inh_Nonterminal  -> (Syn_Nonterminal )
wrap_Nonterminal (T_Nonterminal act) (Inh_Nonterminal _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg22 = T_Nonterminal_vIn22 _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns
        (T_Nonterminal_vOut22 _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap') <- return (inv_Nonterminal_s23 sem arg22)
        return (Syn_Nonterminal _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap')
   )

-- cata
{-# INLINE sem_Nonterminal #-}
sem_Nonterminal :: Nonterminal  -> T_Nonterminal 
sem_Nonterminal ( Nonterminal nt_ params_ inh_ syn_ prods_ ) = sem_Nonterminal_Nonterminal nt_ params_ inh_ syn_ ( sem_Productions prods_ )

-- semantic domain
newtype T_Nonterminal  = T_Nonterminal {
                                       attach_T_Nonterminal :: Identity (T_Nonterminal_s23 )
                                       }
newtype T_Nonterminal_s23  = C_Nonterminal_s23 {
                                               inv_Nonterminal_s23 :: (T_Nonterminal_v22 )
                                               }
data T_Nonterminal_s24  = C_Nonterminal_s24
type T_Nonterminal_v22  = (T_Nonterminal_vIn22 ) -> (T_Nonterminal_vOut22 )
data T_Nonterminal_vIn22  = T_Nonterminal_vIn22 (Derivings) (Maybe String) (Map Identifier Attributes) ( Attributes ) (Set NontermIdent) ( DataTypes ) ([String]) (Bool) (Map Identifier Attributes) (TypeSyns)
data T_Nonterminal_vOut22  = T_Nonterminal_vOut22 (Set NontermIdent) (Map Identifier Attributes) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) ([(PP_Doc, Attributes)]) (PP_Doc) (PP_Doc) (PP_Doc) (Map Identifier Attributes)
{-# NOINLINE sem_Nonterminal_Nonterminal #-}
sem_Nonterminal_Nonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_Productions  -> T_Nonterminal 
sem_Nonterminal_Nonterminal arg_nt_ _ arg_inh_ arg_syn_ arg_prods_ = T_Nonterminal (return st23) where
   {-# NOINLINE st23 #-}
   st23 = let
      v22 :: T_Nonterminal_v22 
      v22 = \ (T_Nonterminal_vIn22 _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns) -> ( let
         _prodsX38 = Control.Monad.Identity.runIdentity (attach_T_Productions (arg_prods_))
         (T_Productions_vOut37 _prodsIhasMoreProds _prodsIppA _prodsIppCata _prodsIppDL _prodsIppL _prodsIppLI _prodsIppR _prodsIppRA _prodsIppSF _prodsIppSPF _prodsIprdInh) = inv_Productions_s38 _prodsX38 (T_Productions_vIn37 _prodsOext _prodsOinh _prodsOinhMap _prodsOinhNoGroup _prodsOnewAtts _prodsOnewNT _prodsOnewProds _prodsOo_noGroup _prodsOo_rename _prodsOppNt _prodsOsyn _prodsOsynMap _prodsOsynNoGroup)
         _lhsOinhMap' :: Map Identifier Attributes
         _lhsOinhMap' = rule70 arg_inh_ arg_nt_
         _lhsOsynMap' :: Map Identifier Attributes
         _lhsOsynMap' = rule71 arg_nt_ arg_syn_
         _inhNoGroup = rule72 _lhsIo_noGroup _prodsIprdInh
         _synNoGroup = rule73 _lhsIo_noGroup arg_syn_
         _prodsOinhNoGroup = rule74 _inhNoGroup
         _prodsOsynNoGroup = rule75 _synNoGroup
         _prodsOnewProds = rule76 _lhsInewProds arg_nt_
         _lhsOextendedNTs :: Set NontermIdent
         _lhsOextendedNTs = rule77 _prodsIhasMoreProds arg_nt_
         _ppNt = rule78 arg_nt_
         _prodsOppNt = rule79 _ppNt
         _lhsOppD :: PP_Doc
         _lhsOppD = rule80 _lhsIderivs _lhsInewNTs _lhsItSyns _ppNt _prodsIppDL arg_nt_
         _lhsOppDI :: [PP_Doc]
         _lhsOppDI = rule81 _lhsInewNTs _ppNt arg_nt_
         _ntLabel = rule82 _ppNt
         _lhsOppL :: PP_Doc
         _lhsOppL = rule83 _lhsInewNTs _ntLabel _ppNt _prodsIppL arg_nt_
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule84 _lhsInewNTs _ntLabel _prodsIppLI arg_nt_
         _lhsOppA :: PP_Doc
         _lhsOppA = rule85 _inhNoGroup _lhsInewNTs _ppNt _prodsIppA _synNoGroup arg_inh_ arg_nt_ arg_syn_
         _lhsOppAI :: [PP_Doc]
         _lhsOppAI = rule86 _lhsInewNTs _ppNt arg_nt_
         _lhsOppNtL :: [(PP_Doc, Attributes)]
         _lhsOppNtL = rule87 arg_inh_ arg_nt_ arg_syn_
         _prodsOnewNT = rule88 _lhsInewNTs arg_nt_
         _lhsOppR :: PP_Doc
         _lhsOppR = rule89 _prodsIppR arg_nt_
         _lhsOppCata :: PP_Doc
         _lhsOppCata = rule90 _ppNt _prodsIppCata
         _prodsOsyn = rule91 arg_syn_
         _prodsOinh = rule92 arg_inh_
         _lhsOppSF :: PP_Doc
         _lhsOppSF = rule93 _inhNoGroup _ppNt _prodsIppSPF _synNoGroup
         _lhsOppW :: PP_Doc
         _lhsOppW = rule94 _inhNoGroup _ppNt arg_inh_
         _prodsOext = rule95 _lhsIext
         _prodsOinhMap = rule96 _lhsIinhMap
         _prodsOnewAtts = rule97 _lhsInewAtts
         _prodsOo_noGroup = rule98 _lhsIo_noGroup
         _prodsOo_rename = rule99 _lhsIo_rename
         _prodsOsynMap = rule100 _lhsIsynMap
         __result_ = T_Nonterminal_vOut22 _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap'
         in __result_ )
     in C_Nonterminal_s23 v22
   {-# INLINE rule70 #-}
   {-# LINE 7 "src-ag/DistChildAttr.ag" #-}
   rule70 = \ inh_ nt_ ->
                                 {-# LINE 7 "src-ag/DistChildAttr.ag" #-}
                                 Map.singleton nt_ inh_
                                 {-# LINE 1320 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule71 #-}
   {-# LINE 8 "src-ag/DistChildAttr.ag" #-}
   rule71 = \ nt_ syn_ ->
                                 {-# LINE 8 "src-ag/DistChildAttr.ag" #-}
                                 Map.singleton nt_ syn_
                                 {-# LINE 1326 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule72 #-}
   {-# LINE 51 "src-ag/AG2AspectAG.ag" #-}
   rule72 = \ ((_lhsIo_noGroup) :: [String]) ((_prodsIprdInh) :: Attributes) ->
                                        {-# LINE 51 "src-ag/AG2AspectAG.ag" #-}
                                        Map.filterWithKey (\att _ -> elem (getName att) _lhsIo_noGroup) _prodsIprdInh
                                        {-# LINE 1332 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule73 #-}
   {-# LINE 52 "src-ag/AG2AspectAG.ag" #-}
   rule73 = \ ((_lhsIo_noGroup) :: [String]) syn_ ->
                                        {-# LINE 52 "src-ag/AG2AspectAG.ag" #-}
                                        Map.filterWithKey (\att _ -> elem (getName att) _lhsIo_noGroup) syn_
                                        {-# LINE 1338 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule74 #-}
   {-# LINE 57 "src-ag/AG2AspectAG.ag" #-}
   rule74 = \ _inhNoGroup ->
                                          {-# LINE 57 "src-ag/AG2AspectAG.ag" #-}
                                          map show $ Map.keys _inhNoGroup
                                          {-# LINE 1344 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule75 #-}
   {-# LINE 58 "src-ag/AG2AspectAG.ag" #-}
   rule75 = \ _synNoGroup ->
                                          {-# LINE 58 "src-ag/AG2AspectAG.ag" #-}
                                          map show $ Map.keys _synNoGroup
                                          {-# LINE 1350 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule76 #-}
   {-# LINE 94 "src-ag/AG2AspectAG.ag" #-}
   rule76 = \ ((_lhsInewProds) ::  DataTypes ) nt_ ->
                                   {-# LINE 94 "src-ag/AG2AspectAG.ag" #-}
                                   case Map.lookup nt_ _lhsInewProds of
                                          Just prds -> prds
                                          Nothing   -> Map.empty
                                   {-# LINE 1358 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule77 #-}
   {-# LINE 107 "src-ag/AG2AspectAG.ag" #-}
   rule77 = \ ((_prodsIhasMoreProds) ::  Bool ) nt_ ->
                                                  {-# LINE 107 "src-ag/AG2AspectAG.ag" #-}
                                                  if _prodsIhasMoreProds
                                                  then Set.singleton nt_
                                                  else Set.empty
                                                  {-# LINE 1366 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule78 #-}
   {-# LINE 173 "src-ag/AG2AspectAG.ag" #-}
   rule78 = \ nt_ ->
                                                      {-# LINE 173 "src-ag/AG2AspectAG.ag" #-}
                                                      pp nt_
                                                      {-# LINE 1372 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule79 #-}
   {-# LINE 190 "src-ag/AG2AspectAG.ag" #-}
   rule79 = \ _ppNt ->
                                                     {-# LINE 190 "src-ag/AG2AspectAG.ag" #-}
                                                     _ppNt
                                                     {-# LINE 1378 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule80 #-}
   {-# LINE 209 "src-ag/AG2AspectAG.ag" #-}
   rule80 = \ ((_lhsIderivs) :: Derivings) ((_lhsInewNTs) :: Set NontermIdent) ((_lhsItSyns) :: TypeSyns) _ppNt ((_prodsIppDL) :: [PP_Doc]) nt_ ->
                                       {-# LINE 209 "src-ag/AG2AspectAG.ag" #-}
                                       if (Set.member nt_ _lhsInewNTs)
                                       then  case (lookup nt_ _lhsItSyns) of
                                                      Nothing ->  "data " >|< _ppNt
                                                                   >|< " = " >|< vlist_sep " | " _prodsIppDL >-<
                                                                  case (Map.lookup nt_ _lhsIderivs) of
                                                                   Just ntds -> pp "  deriving " >|<  (ppListSep "(" ")" ", " $ Set.elems ntds)
                                                                   Nothing   -> empty
                                                      Just tp ->  "type " >|< _ppNt     >|< " = " >|< ppShow tp
                                       else  empty
                                       {-# LINE 1392 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule81 #-}
   {-# LINE 222 "src-ag/AG2AspectAG.ag" #-}
   rule81 = \ ((_lhsInewNTs) :: Set NontermIdent) _ppNt nt_ ->
                                       {-# LINE 222 "src-ag/AG2AspectAG.ag" #-}
                                       if (not $ Set.member nt_ _lhsInewNTs)
                                       then  [ _ppNt     ]
                                       else  [ ]
                                       {-# LINE 1400 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule82 #-}
   {-# LINE 262 "src-ag/AG2AspectAG.ag" #-}
   rule82 = \ _ppNt ->
                                                    {-# LINE 262 "src-ag/AG2AspectAG.ag" #-}
                                                    "nt_" >|< _ppNt
                                                    {-# LINE 1406 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule83 #-}
   {-# LINE 264 "src-ag/AG2AspectAG.ag" #-}
   rule83 = \ ((_lhsInewNTs) :: Set NontermIdent) _ntLabel _ppNt ((_prodsIppL) :: PP_Doc) nt_ ->
                                                     {-# LINE 264 "src-ag/AG2AspectAG.ag" #-}
                                                     ( if (Set.member nt_ _lhsInewNTs)
                                                       then _ntLabel     >|< " = proxy :: Proxy " >|< _ppNt
                                                       else empty)  >-<
                                                     _prodsIppL
                                                     {-# LINE 1415 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule84 #-}
   {-# LINE 269 "src-ag/AG2AspectAG.ag" #-}
   rule84 = \ ((_lhsInewNTs) :: Set NontermIdent) _ntLabel ((_prodsIppLI) :: [PP_Doc]) nt_ ->
                                                     {-# LINE 269 "src-ag/AG2AspectAG.ag" #-}
                                                     ( if (not $ Set.member nt_ _lhsInewNTs)
                                                       then [ _ntLabel     ]
                                                       else [ ])  ++
                                                     _prodsIppLI
                                                     {-# LINE 1424 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule85 #-}
   {-# LINE 324 "src-ag/AG2AspectAG.ag" #-}
   rule85 = \ _inhNoGroup ((_lhsInewNTs) :: Set NontermIdent) _ppNt ((_prodsIppA) :: PP_Doc) _synNoGroup inh_ nt_ syn_ ->
                                                     {-# LINE 324 "src-ag/AG2AspectAG.ag" #-}
                                                     ( if (Set.member nt_ _lhsInewNTs)
                                                       then
                                                              defAttRec (pp "InhG") _ppNt     inh_ _inhNoGroup     >-<
                                                              defAttRec (pp "SynG") _ppNt     syn_ _synNoGroup
                                                       else   empty) >-<
                                                     _prodsIppA
                                                     {-# LINE 1435 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule86 #-}
   {-# LINE 338 "src-ag/AG2AspectAG.ag" #-}
   rule86 = \ ((_lhsInewNTs) :: Set NontermIdent) _ppNt nt_ ->
                                                     {-# LINE 338 "src-ag/AG2AspectAG.ag" #-}
                                                     if (not $ Set.member nt_ _lhsInewNTs)
                                                     then [ ppName [(pp "InhG"), _ppNt     ] >#< pp "(..)", ppName [(pp "SynG"), _ppNt     ] >#< pp "(..)" ]
                                                     else [ ]
                                                     {-# LINE 1443 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule87 #-}
   {-# LINE 406 "src-ag/AG2AspectAG.ag" #-}
   rule87 = \ inh_ nt_ syn_ ->
                                                     {-# LINE 406 "src-ag/AG2AspectAG.ag" #-}
                                                     [ ("nt_" >|< nt_, Map.union inh_ syn_) ]
                                                     {-# LINE 1449 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule88 #-}
   {-# LINE 415 "src-ag/AG2AspectAG.ag" #-}
   rule88 = \ ((_lhsInewNTs) :: Set NontermIdent) nt_ ->
                                                         {-# LINE 415 "src-ag/AG2AspectAG.ag" #-}
                                                         Set.member nt_ _lhsInewNTs
                                                         {-# LINE 1455 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule89 #-}
   {-# LINE 425 "src-ag/AG2AspectAG.ag" #-}
   rule89 = \ ((_prodsIppR) :: PP_Doc) nt_ ->
                                                     {-# LINE 425 "src-ag/AG2AspectAG.ag" #-}
                                                     pp "----" >|< pp nt_ >-< _prodsIppR
                                                     {-# LINE 1461 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule90 #-}
   {-# LINE 735 "src-ag/AG2AspectAG.ag" #-}
   rule90 = \ _ppNt ((_prodsIppCata) :: PP_Doc) ->
                                                      {-# LINE 735 "src-ag/AG2AspectAG.ag" #-}
                                                      "----" >|< _ppNt     >-< _prodsIppCata
                                                      {-# LINE 1467 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule91 #-}
   {-# LINE 766 "src-ag/AG2AspectAG.ag" #-}
   rule91 = \ syn_ ->
                                                     {-# LINE 766 "src-ag/AG2AspectAG.ag" #-}
                                                     syn_
                                                     {-# LINE 1473 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule92 #-}
   {-# LINE 767 "src-ag/AG2AspectAG.ag" #-}
   rule92 = \ inh_ ->
                                                     {-# LINE 767 "src-ag/AG2AspectAG.ag" #-}
                                                     inh_
                                                     {-# LINE 1479 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule93 #-}
   {-# LINE 779 "src-ag/AG2AspectAG.ag" #-}
   rule93 = \ _inhNoGroup _ppNt ((_prodsIppSPF) :: PP_Doc) _synNoGroup ->
                                           {-# LINE 779 "src-ag/AG2AspectAG.ag" #-}
                                           let      inhAtts = attTypes _inhNoGroup
                                                    synAtts = attTypes _synNoGroup
                                           in
                                                    "----" >|< _ppNt     >-<
                                                    "type T_" >|< _ppNt     >|< " = " >|<
                                                    "(Record " >|<
                                                    inhAtts >|<
                                                    "(HCons (LVPair (Proxy Att_inh) InhG_" >|< _ppNt     >|< ") HNil))" >|<
                                                    replicate (length inhAtts) ")" >|< " -> " >|<
                                                    "(Record " >|<
                                                    synAtts >|<
                                                    "(HCons (LVPair (Proxy Att_syn) SynG_" >|< _ppNt     >|< ") HNil))" >|<
                                                    replicate (length synAtts) ")" >-<
                                                    "-- instance SemType T_" >|< _ppNt     >|< " " >|< _ppNt     >-<
                                                    "-- sem_" >|< _ppNt     >|< " :: " >|< _ppNt     >|< " -> T_" >|<  _ppNt     >-<
                                                    _prodsIppSPF
                                           {-# LINE 1500 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule94 #-}
   {-# LINE 847 "src-ag/AG2AspectAG.ag" #-}
   rule94 = \ _inhNoGroup _ppNt inh_ ->
                                              {-# LINE 847 "src-ag/AG2AspectAG.ag" #-}
                                              ppName [pp "wrap", _ppNt    ] >|< " sem " >|< attVars inh_ >|< " = " >-<
                                              "   sem " >|< attFields inh_ _inhNoGroup     _ppNt
                                              {-# LINE 1507 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule95 #-}
   rule95 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule96 #-}
   rule96 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule97 #-}
   rule97 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule98 #-}
   rule98 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule99 #-}
   rule99 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule100 #-}
   rule100 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap

-- Nonterminals ------------------------------------------------
-- wrapper
data Inh_Nonterminals  = Inh_Nonterminals { derivs_Inh_Nonterminals :: (Derivings), ext_Inh_Nonterminals :: (Maybe String), inhMap_Inh_Nonterminals :: (Map Identifier Attributes), newAtts_Inh_Nonterminals :: ( Attributes ), newNTs_Inh_Nonterminals :: (Set NontermIdent), newProds_Inh_Nonterminals :: ( DataTypes ), o_noGroup_Inh_Nonterminals :: ([String]), o_rename_Inh_Nonterminals :: (Bool), synMap_Inh_Nonterminals :: (Map Identifier Attributes), tSyns_Inh_Nonterminals :: (TypeSyns) }
data Syn_Nonterminals  = Syn_Nonterminals { extendedNTs_Syn_Nonterminals :: (Set NontermIdent), inhMap'_Syn_Nonterminals :: (Map Identifier Attributes), ppA_Syn_Nonterminals :: (PP_Doc), ppAI_Syn_Nonterminals :: ([PP_Doc]), ppCata_Syn_Nonterminals :: (PP_Doc), ppD_Syn_Nonterminals :: (PP_Doc), ppDI_Syn_Nonterminals :: ([PP_Doc]), ppL_Syn_Nonterminals :: (PP_Doc), ppLI_Syn_Nonterminals :: ([PP_Doc]), ppNtL_Syn_Nonterminals :: ([(PP_Doc, Attributes)]), ppR_Syn_Nonterminals :: (PP_Doc), ppSF_Syn_Nonterminals :: (PP_Doc), ppW_Syn_Nonterminals :: (PP_Doc), synMap'_Syn_Nonterminals :: (Map Identifier Attributes) }
{-# INLINABLE wrap_Nonterminals #-}
wrap_Nonterminals :: T_Nonterminals  -> Inh_Nonterminals  -> (Syn_Nonterminals )
wrap_Nonterminals (T_Nonterminals act) (Inh_Nonterminals _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg25 = T_Nonterminals_vIn25 _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns
        (T_Nonterminals_vOut25 _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap') <- return (inv_Nonterminals_s26 sem arg25)
        return (Syn_Nonterminals _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap')
   )

-- cata
{-# NOINLINE sem_Nonterminals #-}
sem_Nonterminals :: Nonterminals  -> T_Nonterminals 
sem_Nonterminals list = Prelude.foldr sem_Nonterminals_Cons sem_Nonterminals_Nil (Prelude.map sem_Nonterminal list)

-- semantic domain
newtype T_Nonterminals  = T_Nonterminals {
                                         attach_T_Nonterminals :: Identity (T_Nonterminals_s26 )
                                         }
newtype T_Nonterminals_s26  = C_Nonterminals_s26 {
                                                 inv_Nonterminals_s26 :: (T_Nonterminals_v25 )
                                                 }
data T_Nonterminals_s27  = C_Nonterminals_s27
type T_Nonterminals_v25  = (T_Nonterminals_vIn25 ) -> (T_Nonterminals_vOut25 )
data T_Nonterminals_vIn25  = T_Nonterminals_vIn25 (Derivings) (Maybe String) (Map Identifier Attributes) ( Attributes ) (Set NontermIdent) ( DataTypes ) ([String]) (Bool) (Map Identifier Attributes) (TypeSyns)
data T_Nonterminals_vOut25  = T_Nonterminals_vOut25 (Set NontermIdent) (Map Identifier Attributes) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) ([(PP_Doc, Attributes)]) (PP_Doc) (PP_Doc) (PP_Doc) (Map Identifier Attributes)
{-# NOINLINE sem_Nonterminals_Cons #-}
sem_Nonterminals_Cons :: T_Nonterminal  -> T_Nonterminals  -> T_Nonterminals 
sem_Nonterminals_Cons arg_hd_ arg_tl_ = T_Nonterminals (return st26) where
   {-# NOINLINE st26 #-}
   st26 = let
      v25 :: T_Nonterminals_v25 
      v25 = \ (T_Nonterminals_vIn25 _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns) -> ( let
         _hdX23 = Control.Monad.Identity.runIdentity (attach_T_Nonterminal (arg_hd_))
         _tlX26 = Control.Monad.Identity.runIdentity (attach_T_Nonterminals (arg_tl_))
         (T_Nonterminal_vOut22 _hdIextendedNTs _hdIinhMap' _hdIppA _hdIppAI _hdIppCata _hdIppD _hdIppDI _hdIppL _hdIppLI _hdIppNtL _hdIppR _hdIppSF _hdIppW _hdIsynMap') = inv_Nonterminal_s23 _hdX23 (T_Nonterminal_vIn22 _hdOderivs _hdOext _hdOinhMap _hdOnewAtts _hdOnewNTs _hdOnewProds _hdOo_noGroup _hdOo_rename _hdOsynMap _hdOtSyns)
         (T_Nonterminals_vOut25 _tlIextendedNTs _tlIinhMap' _tlIppA _tlIppAI _tlIppCata _tlIppD _tlIppDI _tlIppL _tlIppLI _tlIppNtL _tlIppR _tlIppSF _tlIppW _tlIsynMap') = inv_Nonterminals_s26 _tlX26 (T_Nonterminals_vIn25 _tlOderivs _tlOext _tlOinhMap _tlOnewAtts _tlOnewNTs _tlOnewProds _tlOo_noGroup _tlOo_rename _tlOsynMap _tlOtSyns)
         _lhsOextendedNTs :: Set NontermIdent
         _lhsOextendedNTs = rule101 _hdIextendedNTs _tlIextendedNTs
         _lhsOinhMap' :: Map Identifier Attributes
         _lhsOinhMap' = rule102 _hdIinhMap' _tlIinhMap'
         _lhsOppA :: PP_Doc
         _lhsOppA = rule103 _hdIppA _tlIppA
         _lhsOppAI :: [PP_Doc]
         _lhsOppAI = rule104 _hdIppAI _tlIppAI
         _lhsOppCata :: PP_Doc
         _lhsOppCata = rule105 _hdIppCata _tlIppCata
         _lhsOppD :: PP_Doc
         _lhsOppD = rule106 _hdIppD _tlIppD
         _lhsOppDI :: [PP_Doc]
         _lhsOppDI = rule107 _hdIppDI _tlIppDI
         _lhsOppL :: PP_Doc
         _lhsOppL = rule108 _hdIppL _tlIppL
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule109 _hdIppLI _tlIppLI
         _lhsOppNtL :: [(PP_Doc, Attributes)]
         _lhsOppNtL = rule110 _hdIppNtL _tlIppNtL
         _lhsOppR :: PP_Doc
         _lhsOppR = rule111 _hdIppR _tlIppR
         _lhsOppSF :: PP_Doc
         _lhsOppSF = rule112 _hdIppSF _tlIppSF
         _lhsOppW :: PP_Doc
         _lhsOppW = rule113 _hdIppW _tlIppW
         _lhsOsynMap' :: Map Identifier Attributes
         _lhsOsynMap' = rule114 _hdIsynMap' _tlIsynMap'
         _hdOderivs = rule115 _lhsIderivs
         _hdOext = rule116 _lhsIext
         _hdOinhMap = rule117 _lhsIinhMap
         _hdOnewAtts = rule118 _lhsInewAtts
         _hdOnewNTs = rule119 _lhsInewNTs
         _hdOnewProds = rule120 _lhsInewProds
         _hdOo_noGroup = rule121 _lhsIo_noGroup
         _hdOo_rename = rule122 _lhsIo_rename
         _hdOsynMap = rule123 _lhsIsynMap
         _hdOtSyns = rule124 _lhsItSyns
         _tlOderivs = rule125 _lhsIderivs
         _tlOext = rule126 _lhsIext
         _tlOinhMap = rule127 _lhsIinhMap
         _tlOnewAtts = rule128 _lhsInewAtts
         _tlOnewNTs = rule129 _lhsInewNTs
         _tlOnewProds = rule130 _lhsInewProds
         _tlOo_noGroup = rule131 _lhsIo_noGroup
         _tlOo_rename = rule132 _lhsIo_rename
         _tlOsynMap = rule133 _lhsIsynMap
         _tlOtSyns = rule134 _lhsItSyns
         __result_ = T_Nonterminals_vOut25 _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap'
         in __result_ )
     in C_Nonterminals_s26 v25
   {-# INLINE rule101 #-}
   rule101 = \ ((_hdIextendedNTs) :: Set NontermIdent) ((_tlIextendedNTs) :: Set NontermIdent) ->
     _hdIextendedNTs `Set.union` _tlIextendedNTs
   {-# INLINE rule102 #-}
   rule102 = \ ((_hdIinhMap') :: Map Identifier Attributes) ((_tlIinhMap') :: Map Identifier Attributes) ->
     _hdIinhMap' `Map.union` _tlIinhMap'
   {-# INLINE rule103 #-}
   rule103 = \ ((_hdIppA) :: PP_Doc) ((_tlIppA) :: PP_Doc) ->
     _hdIppA >-< _tlIppA
   {-# INLINE rule104 #-}
   rule104 = \ ((_hdIppAI) :: [PP_Doc]) ((_tlIppAI) :: [PP_Doc]) ->
     _hdIppAI ++ _tlIppAI
   {-# INLINE rule105 #-}
   rule105 = \ ((_hdIppCata) :: PP_Doc) ((_tlIppCata) :: PP_Doc) ->
     _hdIppCata >-< _tlIppCata
   {-# INLINE rule106 #-}
   rule106 = \ ((_hdIppD) :: PP_Doc) ((_tlIppD) :: PP_Doc) ->
     _hdIppD >-< _tlIppD
   {-# INLINE rule107 #-}
   rule107 = \ ((_hdIppDI) :: [PP_Doc]) ((_tlIppDI) :: [PP_Doc]) ->
     _hdIppDI ++ _tlIppDI
   {-# INLINE rule108 #-}
   rule108 = \ ((_hdIppL) :: PP_Doc) ((_tlIppL) :: PP_Doc) ->
     _hdIppL >-< _tlIppL
   {-# INLINE rule109 #-}
   rule109 = \ ((_hdIppLI) :: [PP_Doc]) ((_tlIppLI) :: [PP_Doc]) ->
     _hdIppLI ++ _tlIppLI
   {-# INLINE rule110 #-}
   rule110 = \ ((_hdIppNtL) :: [(PP_Doc, Attributes)]) ((_tlIppNtL) :: [(PP_Doc, Attributes)]) ->
     _hdIppNtL ++ _tlIppNtL
   {-# INLINE rule111 #-}
   rule111 = \ ((_hdIppR) :: PP_Doc) ((_tlIppR) :: PP_Doc) ->
     _hdIppR >-< _tlIppR
   {-# INLINE rule112 #-}
   rule112 = \ ((_hdIppSF) :: PP_Doc) ((_tlIppSF) :: PP_Doc) ->
     _hdIppSF >-< _tlIppSF
   {-# INLINE rule113 #-}
   rule113 = \ ((_hdIppW) :: PP_Doc) ((_tlIppW) :: PP_Doc) ->
     _hdIppW >-< _tlIppW
   {-# INLINE rule114 #-}
   rule114 = \ ((_hdIsynMap') :: Map Identifier Attributes) ((_tlIsynMap') :: Map Identifier Attributes) ->
     _hdIsynMap' `Map.union` _tlIsynMap'
   {-# INLINE rule115 #-}
   rule115 = \ ((_lhsIderivs) :: Derivings) ->
     _lhsIderivs
   {-# INLINE rule116 #-}
   rule116 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule117 #-}
   rule117 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule118 #-}
   rule118 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule119 #-}
   rule119 = \ ((_lhsInewNTs) :: Set NontermIdent) ->
     _lhsInewNTs
   {-# INLINE rule120 #-}
   rule120 = \ ((_lhsInewProds) ::  DataTypes ) ->
     _lhsInewProds
   {-# INLINE rule121 #-}
   rule121 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule122 #-}
   rule122 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule123 #-}
   rule123 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule124 #-}
   rule124 = \ ((_lhsItSyns) :: TypeSyns) ->
     _lhsItSyns
   {-# INLINE rule125 #-}
   rule125 = \ ((_lhsIderivs) :: Derivings) ->
     _lhsIderivs
   {-# INLINE rule126 #-}
   rule126 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule127 #-}
   rule127 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule128 #-}
   rule128 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule129 #-}
   rule129 = \ ((_lhsInewNTs) :: Set NontermIdent) ->
     _lhsInewNTs
   {-# INLINE rule130 #-}
   rule130 = \ ((_lhsInewProds) ::  DataTypes ) ->
     _lhsInewProds
   {-# INLINE rule131 #-}
   rule131 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule132 #-}
   rule132 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule133 #-}
   rule133 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule134 #-}
   rule134 = \ ((_lhsItSyns) :: TypeSyns) ->
     _lhsItSyns
{-# NOINLINE sem_Nonterminals_Nil #-}
sem_Nonterminals_Nil ::  T_Nonterminals 
sem_Nonterminals_Nil  = T_Nonterminals (return st26) where
   {-# NOINLINE st26 #-}
   st26 = let
      v25 :: T_Nonterminals_v25 
      v25 = \ (T_Nonterminals_vIn25 _lhsIderivs _lhsIext _lhsIinhMap _lhsInewAtts _lhsInewNTs _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIsynMap _lhsItSyns) -> ( let
         _lhsOextendedNTs :: Set NontermIdent
         _lhsOextendedNTs = rule135  ()
         _lhsOinhMap' :: Map Identifier Attributes
         _lhsOinhMap' = rule136  ()
         _lhsOppA :: PP_Doc
         _lhsOppA = rule137  ()
         _lhsOppAI :: [PP_Doc]
         _lhsOppAI = rule138  ()
         _lhsOppCata :: PP_Doc
         _lhsOppCata = rule139  ()
         _lhsOppD :: PP_Doc
         _lhsOppD = rule140  ()
         _lhsOppDI :: [PP_Doc]
         _lhsOppDI = rule141  ()
         _lhsOppL :: PP_Doc
         _lhsOppL = rule142  ()
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule143  ()
         _lhsOppNtL :: [(PP_Doc, Attributes)]
         _lhsOppNtL = rule144  ()
         _lhsOppR :: PP_Doc
         _lhsOppR = rule145  ()
         _lhsOppSF :: PP_Doc
         _lhsOppSF = rule146  ()
         _lhsOppW :: PP_Doc
         _lhsOppW = rule147  ()
         _lhsOsynMap' :: Map Identifier Attributes
         _lhsOsynMap' = rule148  ()
         __result_ = T_Nonterminals_vOut25 _lhsOextendedNTs _lhsOinhMap' _lhsOppA _lhsOppAI _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppNtL _lhsOppR _lhsOppSF _lhsOppW _lhsOsynMap'
         in __result_ )
     in C_Nonterminals_s26 v25
   {-# INLINE rule135 #-}
   rule135 = \  (_ :: ()) ->
     Set.empty
   {-# INLINE rule136 #-}
   rule136 = \  (_ :: ()) ->
     Map.empty
   {-# INLINE rule137 #-}
   rule137 = \  (_ :: ()) ->
     empty
   {-# INLINE rule138 #-}
   rule138 = \  (_ :: ()) ->
     []
   {-# INLINE rule139 #-}
   rule139 = \  (_ :: ()) ->
     empty
   {-# INLINE rule140 #-}
   rule140 = \  (_ :: ()) ->
     empty
   {-# INLINE rule141 #-}
   rule141 = \  (_ :: ()) ->
     []
   {-# INLINE rule142 #-}
   rule142 = \  (_ :: ()) ->
     empty
   {-# INLINE rule143 #-}
   rule143 = \  (_ :: ()) ->
     []
   {-# INLINE rule144 #-}
   rule144 = \  (_ :: ()) ->
     []
   {-# INLINE rule145 #-}
   rule145 = \  (_ :: ()) ->
     empty
   {-# INLINE rule146 #-}
   rule146 = \  (_ :: ()) ->
     empty
   {-# INLINE rule147 #-}
   rule147 = \  (_ :: ()) ->
     empty
   {-# INLINE rule148 #-}
   rule148 = \  (_ :: ()) ->
     Map.empty

-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern  = Inh_Pattern {  }
data Syn_Pattern  = Syn_Pattern { copy_Syn_Pattern :: (Pattern), info_Syn_Pattern :: ((Identifier, Identifier)) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern  -> Inh_Pattern  -> (Syn_Pattern )
wrap_Pattern (T_Pattern act) (Inh_Pattern ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg28 = T_Pattern_vIn28 
        (T_Pattern_vOut28 _lhsOcopy _lhsOinfo) <- return (inv_Pattern_s29 sem arg28)
        return (Syn_Pattern _lhsOcopy _lhsOinfo)
   )

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

-- semantic domain
newtype T_Pattern  = T_Pattern {
                               attach_T_Pattern :: Identity (T_Pattern_s29 )
                               }
newtype T_Pattern_s29  = C_Pattern_s29 {
                                       inv_Pattern_s29 :: (T_Pattern_v28 )
                                       }
data T_Pattern_s30  = C_Pattern_s30
type T_Pattern_v28  = (T_Pattern_vIn28 ) -> (T_Pattern_vOut28 )
data T_Pattern_vIn28  = T_Pattern_vIn28 
data T_Pattern_vOut28  = T_Pattern_vOut28 (Pattern) ((Identifier, Identifier))
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns  -> T_Pattern 
sem_Pattern_Constr arg_name_ arg_pats_ = T_Pattern (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Pattern_v28 
      v28 = \ (T_Pattern_vIn28 ) -> ( let
         _patsX32 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_))
         (T_Patterns_vOut31 _patsIcopy) = inv_Patterns_s32 _patsX32 (T_Patterns_vIn31 )
         _lhsOinfo :: (Identifier, Identifier)
         _lhsOinfo = rule149  ()
         _copy = rule150 _patsIcopy arg_name_
         _lhsOcopy :: Pattern
         _lhsOcopy = rule151 _copy
         __result_ = T_Pattern_vOut28 _lhsOcopy _lhsOinfo
         in __result_ )
     in C_Pattern_s29 v28
   {-# INLINE rule149 #-}
   {-# LINE 383 "src-ag/AG2AspectAG.ag" #-}
   rule149 = \  (_ :: ()) ->
                                                    {-# LINE 383 "src-ag/AG2AspectAG.ag" #-}
                                                    error "Pattern Constr undefined!!"
                                                    {-# LINE 1858 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule150 #-}
   rule150 = \ ((_patsIcopy) :: Patterns) name_ ->
     Constr name_ _patsIcopy
   {-# INLINE rule151 #-}
   rule151 = \ _copy ->
     _copy
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns  -> T_Pattern 
sem_Pattern_Product arg_pos_ arg_pats_ = T_Pattern (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Pattern_v28 
      v28 = \ (T_Pattern_vIn28 ) -> ( let
         _patsX32 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_pats_))
         (T_Patterns_vOut31 _patsIcopy) = inv_Patterns_s32 _patsX32 (T_Patterns_vIn31 )
         _lhsOinfo :: (Identifier, Identifier)
         _lhsOinfo = rule152  ()
         _copy = rule153 _patsIcopy arg_pos_
         _lhsOcopy :: Pattern
         _lhsOcopy = rule154 _copy
         __result_ = T_Pattern_vOut28 _lhsOcopy _lhsOinfo
         in __result_ )
     in C_Pattern_s29 v28
   {-# INLINE rule152 #-}
   {-# LINE 384 "src-ag/AG2AspectAG.ag" #-}
   rule152 = \  (_ :: ()) ->
                                                    {-# LINE 384 "src-ag/AG2AspectAG.ag" #-}
                                                    error "Pattern Product undefined!!"
                                                    {-# LINE 1887 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule153 #-}
   rule153 = \ ((_patsIcopy) :: Patterns) pos_ ->
     Product pos_ _patsIcopy
   {-# INLINE rule154 #-}
   rule154 = \ _copy ->
     _copy
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern  -> T_Pattern 
sem_Pattern_Alias arg_field_ arg_attr_ arg_pat_ = T_Pattern (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Pattern_v28 
      v28 = \ (T_Pattern_vIn28 ) -> ( let
         _patX29 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_))
         (T_Pattern_vOut28 _patIcopy _patIinfo) = inv_Pattern_s29 _patX29 (T_Pattern_vIn28 )
         _lhsOinfo :: (Identifier, Identifier)
         _lhsOinfo = rule155 arg_attr_ arg_field_
         _copy = rule156 _patIcopy arg_attr_ arg_field_
         _lhsOcopy :: Pattern
         _lhsOcopy = rule157 _copy
         __result_ = T_Pattern_vOut28 _lhsOcopy _lhsOinfo
         in __result_ )
     in C_Pattern_s29 v28
   {-# INLINE rule155 #-}
   {-# LINE 382 "src-ag/AG2AspectAG.ag" #-}
   rule155 = \ attr_ field_ ->
                                                    {-# LINE 382 "src-ag/AG2AspectAG.ag" #-}
                                                    (field_, attr_)
                                                    {-# LINE 1916 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule156 #-}
   rule156 = \ ((_patIcopy) :: Pattern) attr_ field_ ->
     Alias field_ attr_ _patIcopy
   {-# INLINE rule157 #-}
   rule157 = \ _copy ->
     _copy
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern  -> T_Pattern 
sem_Pattern_Irrefutable arg_pat_ = T_Pattern (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Pattern_v28 
      v28 = \ (T_Pattern_vIn28 ) -> ( let
         _patX29 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pat_))
         (T_Pattern_vOut28 _patIcopy _patIinfo) = inv_Pattern_s29 _patX29 (T_Pattern_vIn28 )
         _copy = rule158 _patIcopy
         _lhsOcopy :: Pattern
         _lhsOcopy = rule159 _copy
         _lhsOinfo :: (Identifier, Identifier)
         _lhsOinfo = rule160 _patIinfo
         __result_ = T_Pattern_vOut28 _lhsOcopy _lhsOinfo
         in __result_ )
     in C_Pattern_s29 v28
   {-# INLINE rule158 #-}
   rule158 = \ ((_patIcopy) :: Pattern) ->
     Irrefutable _patIcopy
   {-# INLINE rule159 #-}
   rule159 = \ _copy ->
     _copy
   {-# INLINE rule160 #-}
   rule160 = \ ((_patIinfo) :: (Identifier, Identifier)) ->
     _patIinfo
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern 
sem_Pattern_Underscore arg_pos_ = T_Pattern (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Pattern_v28 
      v28 = \ (T_Pattern_vIn28 ) -> ( let
         _lhsOinfo :: (Identifier, Identifier)
         _lhsOinfo = rule161  ()
         _copy = rule162 arg_pos_
         _lhsOcopy :: Pattern
         _lhsOcopy = rule163 _copy
         __result_ = T_Pattern_vOut28 _lhsOcopy _lhsOinfo
         in __result_ )
     in C_Pattern_s29 v28
   {-# INLINE rule161 #-}
   {-# LINE 385 "src-ag/AG2AspectAG.ag" #-}
   rule161 = \  (_ :: ()) ->
                                                    {-# LINE 385 "src-ag/AG2AspectAG.ag" #-}
                                                    error "Pattern Underscore undefined!!"
                                                    {-# LINE 1969 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule162 #-}
   rule162 = \ pos_ ->
     Underscore pos_
   {-# INLINE rule163 #-}
   rule163 = \ _copy ->
     _copy

-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns  = Inh_Patterns {  }
data Syn_Patterns  = Syn_Patterns { copy_Syn_Patterns :: (Patterns) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns  -> Inh_Patterns  -> (Syn_Patterns )
wrap_Patterns (T_Patterns act) (Inh_Patterns ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg31 = T_Patterns_vIn31 
        (T_Patterns_vOut31 _lhsOcopy) <- return (inv_Patterns_s32 sem arg31)
        return (Syn_Patterns _lhsOcopy)
   )

-- cata
{-# NOINLINE sem_Patterns #-}
sem_Patterns :: Patterns  -> T_Patterns 
sem_Patterns list = Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list)

-- semantic domain
newtype T_Patterns  = T_Patterns {
                                 attach_T_Patterns :: Identity (T_Patterns_s32 )
                                 }
newtype T_Patterns_s32  = C_Patterns_s32 {
                                         inv_Patterns_s32 :: (T_Patterns_v31 )
                                         }
data T_Patterns_s33  = C_Patterns_s33
type T_Patterns_v31  = (T_Patterns_vIn31 ) -> (T_Patterns_vOut31 )
data T_Patterns_vIn31  = T_Patterns_vIn31 
data T_Patterns_vOut31  = T_Patterns_vOut31 (Patterns)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern  -> T_Patterns  -> T_Patterns 
sem_Patterns_Cons arg_hd_ arg_tl_ = T_Patterns (return st32) where
   {-# NOINLINE st32 #-}
   st32 = let
      v31 :: T_Patterns_v31 
      v31 = \ (T_Patterns_vIn31 ) -> ( let
         _hdX29 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_hd_))
         _tlX32 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_tl_))
         (T_Pattern_vOut28 _hdIcopy _hdIinfo) = inv_Pattern_s29 _hdX29 (T_Pattern_vIn28 )
         (T_Patterns_vOut31 _tlIcopy) = inv_Patterns_s32 _tlX32 (T_Patterns_vIn31 )
         _copy = rule164 _hdIcopy _tlIcopy
         _lhsOcopy :: Patterns
         _lhsOcopy = rule165 _copy
         __result_ = T_Patterns_vOut31 _lhsOcopy
         in __result_ )
     in C_Patterns_s32 v31
   {-# INLINE rule164 #-}
   rule164 = \ ((_hdIcopy) :: Pattern) ((_tlIcopy) :: Patterns) ->
     (:) _hdIcopy _tlIcopy
   {-# INLINE rule165 #-}
   rule165 = \ _copy ->
     _copy
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil ::  T_Patterns 
sem_Patterns_Nil  = T_Patterns (return st32) where
   {-# NOINLINE st32 #-}
   st32 = let
      v31 :: T_Patterns_v31 
      v31 = \ (T_Patterns_vIn31 ) -> ( let
         _copy = rule166  ()
         _lhsOcopy :: Patterns
         _lhsOcopy = rule167 _copy
         __result_ = T_Patterns_vOut31 _lhsOcopy
         in __result_ )
     in C_Patterns_s32 v31
   {-# INLINE rule166 #-}
   rule166 = \  (_ :: ()) ->
     []
   {-# INLINE rule167 #-}
   rule167 = \ _copy ->
     _copy

-- Production --------------------------------------------------
-- wrapper
data Inh_Production  = Inh_Production { ext_Inh_Production :: (Maybe String), inh_Inh_Production :: ( Attributes ), inhMap_Inh_Production :: (Map Identifier Attributes), inhNoGroup_Inh_Production :: ([String]), newAtts_Inh_Production :: ( Attributes ), newNT_Inh_Production :: (Bool), newProds_Inh_Production :: ( Map.Map ConstructorIdent FieldMap ), o_noGroup_Inh_Production :: ([String]), o_rename_Inh_Production :: (Bool), ppNt_Inh_Production :: (PP_Doc), syn_Inh_Production :: ( Attributes ), synMap_Inh_Production :: (Map Identifier Attributes), synNoGroup_Inh_Production :: ([String]) }
data Syn_Production  = Syn_Production { hasMoreProds_Syn_Production :: ( Bool ), ppA_Syn_Production :: (PP_Doc), ppCata_Syn_Production :: (PP_Doc), ppD_Syn_Production :: (PP_Doc), ppDI_Syn_Production :: ([PP_Doc]), ppL_Syn_Production :: (PP_Doc), ppLI_Syn_Production :: ([PP_Doc]), ppR_Syn_Production :: (PP_Doc), ppRA_Syn_Production :: ([PP_Doc]), ppSF_Syn_Production :: (PP_Doc), ppSPF_Syn_Production :: (PP_Doc), prdInh_Syn_Production :: (Attributes) }
{-# INLINABLE wrap_Production #-}
wrap_Production :: T_Production  -> Inh_Production  -> (Syn_Production )
wrap_Production (T_Production act) (Inh_Production _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg34 = T_Production_vIn34 _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup
        (T_Production_vOut34 _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh) <- return (inv_Production_s35 sem arg34)
        return (Syn_Production _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh)
   )

-- cata
{-# INLINE sem_Production #-}
sem_Production :: Production  -> T_Production 
sem_Production ( Production con_ params_ constraints_ children_ rules_ typeSigs_ macro_ ) = sem_Production_Production con_ params_ constraints_ ( sem_Children children_ ) ( sem_Rules rules_ ) ( sem_TypeSigs typeSigs_ ) macro_

-- semantic domain
newtype T_Production  = T_Production {
                                     attach_T_Production :: Identity (T_Production_s35 )
                                     }
newtype T_Production_s35  = C_Production_s35 {
                                             inv_Production_s35 :: (T_Production_v34 )
                                             }
data T_Production_s36  = C_Production_s36
type T_Production_v34  = (T_Production_vIn34 ) -> (T_Production_vOut34 )
data T_Production_vIn34  = T_Production_vIn34 (Maybe String) ( Attributes ) (Map Identifier Attributes) ([String]) ( Attributes ) (Bool) ( Map.Map ConstructorIdent FieldMap ) ([String]) (Bool) (PP_Doc) ( Attributes ) (Map Identifier Attributes) ([String])
data T_Production_vOut34  = T_Production_vOut34 ( Bool ) (PP_Doc) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) (Attributes)
{-# NOINLINE sem_Production_Production #-}
sem_Production_Production :: (ConstructorIdent) -> ([Identifier]) -> ([Type]) -> T_Children  -> T_Rules  -> T_TypeSigs  -> (MaybeMacro) -> T_Production 
sem_Production_Production arg_con_ _ _ arg_children_ arg_rules_ arg_typeSigs_ arg_macro_ = T_Production (return st35) where
   {-# NOINLINE st35 #-}
   st35 = let
      v34 :: T_Production_v34 
      v34 = \ (T_Production_vIn34 _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup) -> ( let
         _childrenX5 = Control.Monad.Identity.runIdentity (attach_T_Children (arg_children_))
         _rulesX44 = Control.Monad.Identity.runIdentity (attach_T_Rules (arg_rules_))
         _typeSigsX50 = Control.Monad.Identity.runIdentity (attach_T_TypeSigs (arg_typeSigs_))
         (T_Children_vOut4 _childrenIidCL _childrenIppCSF _childrenIppDL _childrenIppL _childrenIppLI _childrenIppR _childrenIprdInh) = inv_Children_s5 _childrenX5 (T_Children_vIn4 _childrenOext _childrenOinhMap _childrenOinhNoGroup _childrenOnewAtts _childrenOo_noGroup _childrenOo_rename _childrenOppNt _childrenOppProd _childrenOsynMap _childrenOsynNoGroup)
         (T_Rules_vOut43 _rulesIlocals _rulesIppRL) = inv_Rules_s44 _rulesX44 (T_Rules_vIn43 _rulesOext _rulesOinhNoGroup _rulesOnewAtts _rulesOnewProd _rulesOo_noGroup _rulesOppNt _rulesOppProd _rulesOsynNoGroup)
         (T_TypeSigs_vOut49 ) = inv_TypeSigs_s50 _typeSigsX50 (T_TypeSigs_vIn49 )
         _lhsOhasMoreProds ::  Bool 
         _lhsOhasMoreProds = rule168 _lhsInewProds arg_con_
         _ppProd = rule169 arg_con_
         _prodName = rule170 _lhsIppNt _ppProd
         _conName = rule171 _lhsIo_rename _ppProd _prodName
         _childrenOppProd = rule172 _ppProd
         _rulesOppProd = rule173 _ppProd
         _lhsOppD :: PP_Doc
         _lhsOppD = rule174 _childrenIppDL _conName
         _lhsOppL :: PP_Doc
         _lhsOppL = rule175 _childrenIppL _lhsInewProds arg_con_
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule176 _childrenIppLI _lhsInewProds arg_con_
         _lhsOppA :: PP_Doc
         _lhsOppA = rule177 _prodName _rulesIlocals
         _newProd = rule178 _lhsInewProds arg_con_
         (_ppR,_ppRA) = rule179 _childrenIidCL _childrenIppR _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsIppNt _lhsIsynNoGroup _newProd _prodName _rulesIlocals _rulesIppRL arg_con_
         _lhsOppCata :: PP_Doc
         _lhsOppCata = rule180 _lhsIext _lhsInewNT _newProd _ppRA _prodName arg_macro_
         _lhsOppSF :: PP_Doc
         _lhsOppSF = rule181 _childrenIppCSF _conName _lhsIppNt _prodName arg_con_
         _lhsOppSPF :: PP_Doc
         _lhsOppSPF = rule182 _childrenIppCSF _lhsIppNt _prodName arg_con_
         _lhsOppDI :: [PP_Doc]
         _lhsOppDI = rule183  ()
         _lhsOppR :: PP_Doc
         _lhsOppR = rule184 _ppR
         _lhsOppRA :: [PP_Doc]
         _lhsOppRA = rule185 _ppRA
         _lhsOprdInh :: Attributes
         _lhsOprdInh = rule186 _childrenIprdInh
         _childrenOext = rule187 _lhsIext
         _childrenOinhMap = rule188 _lhsIinhMap
         _childrenOinhNoGroup = rule189 _lhsIinhNoGroup
         _childrenOnewAtts = rule190 _lhsInewAtts
         _childrenOo_noGroup = rule191 _lhsIo_noGroup
         _childrenOo_rename = rule192 _lhsIo_rename
         _childrenOppNt = rule193 _lhsIppNt
         _childrenOsynMap = rule194 _lhsIsynMap
         _childrenOsynNoGroup = rule195 _lhsIsynNoGroup
         _rulesOext = rule196 _lhsIext
         _rulesOinhNoGroup = rule197 _lhsIinhNoGroup
         _rulesOnewAtts = rule198 _lhsInewAtts
         _rulesOnewProd = rule199 _newProd
         _rulesOo_noGroup = rule200 _lhsIo_noGroup
         _rulesOppNt = rule201 _lhsIppNt
         _rulesOsynNoGroup = rule202 _lhsIsynNoGroup
         __result_ = T_Production_vOut34 _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppD _lhsOppDI _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh
         in __result_ )
     in C_Production_s35 v34
   {-# INLINE rule168 #-}
   {-# LINE 103 "src-ag/AG2AspectAG.ag" #-}
   rule168 = \ ((_lhsInewProds) ::  Map.Map ConstructorIdent FieldMap ) con_ ->
                                                 {-# LINE 103 "src-ag/AG2AspectAG.ag" #-}
                                                 not $ Map.member con_ _lhsInewProds
                                                 {-# LINE 2148 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule169 #-}
   {-# LINE 176 "src-ag/AG2AspectAG.ag" #-}
   rule169 = \ con_ ->
                                                      {-# LINE 176 "src-ag/AG2AspectAG.ag" #-}
                                                      pp con_
                                                      {-# LINE 2154 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule170 #-}
   {-# LINE 177 "src-ag/AG2AspectAG.ag" #-}
   rule170 = \ ((_lhsIppNt) :: PP_Doc) _ppProd ->
                                                      {-# LINE 177 "src-ag/AG2AspectAG.ag" #-}
                                                      ppName [_lhsIppNt, _ppProd    ]
                                                      {-# LINE 2160 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule171 #-}
   {-# LINE 178 "src-ag/AG2AspectAG.ag" #-}
   rule171 = \ ((_lhsIo_rename) :: Bool) _ppProd _prodName ->
                                                      {-# LINE 178 "src-ag/AG2AspectAG.ag" #-}
                                                      if _lhsIo_rename
                                                      then _prodName
                                                      else _ppProd
                                                      {-# LINE 2168 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule172 #-}
   {-# LINE 195 "src-ag/AG2AspectAG.ag" #-}
   rule172 = \ _ppProd ->
                                                     {-# LINE 195 "src-ag/AG2AspectAG.ag" #-}
                                                     _ppProd
                                                     {-# LINE 2174 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule173 #-}
   {-# LINE 196 "src-ag/AG2AspectAG.ag" #-}
   rule173 = \ _ppProd ->
                                                     {-# LINE 196 "src-ag/AG2AspectAG.ag" #-}
                                                     _ppProd
                                                     {-# LINE 2180 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule174 #-}
   {-# LINE 228 "src-ag/AG2AspectAG.ag" #-}
   rule174 = \ ((_childrenIppDL) :: [PP_Doc]) _conName ->
                                                    {-# LINE 228 "src-ag/AG2AspectAG.ag" #-}
                                                    _conName     >|< ppListSep " {" "}" ", " _childrenIppDL
                                                    {-# LINE 2186 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule175 #-}
   {-# LINE 275 "src-ag/AG2AspectAG.ag" #-}
   rule175 = \ ((_childrenIppL) :: PP_Doc) ((_lhsInewProds) ::  Map.Map ConstructorIdent FieldMap ) con_ ->
                                                     {-# LINE 275 "src-ag/AG2AspectAG.ag" #-}
                                                     if (Map.member con_ _lhsInewProds)
                                                       then _childrenIppL
                                                       else empty
                                                     {-# LINE 2194 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule176 #-}
   {-# LINE 279 "src-ag/AG2AspectAG.ag" #-}
   rule176 = \ ((_childrenIppLI) :: [PP_Doc]) ((_lhsInewProds) ::  Map.Map ConstructorIdent FieldMap ) con_ ->
                                                     {-# LINE 279 "src-ag/AG2AspectAG.ag" #-}
                                                     if (not $ Map.member con_ _lhsInewProds)
                                                       then _childrenIppLI
                                                       else []
                                                     {-# LINE 2202 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule177 #-}
   {-# LINE 332 "src-ag/AG2AspectAG.ag" #-}
   rule177 = \ _prodName ((_rulesIlocals) :: [Identifier]) ->
                                                     {-# LINE 332 "src-ag/AG2AspectAG.ag" #-}
                                                     defLocalAtts _prodName     (length _rulesIlocals) 1 $ sort _rulesIlocals
                                                     {-# LINE 2208 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule178 #-}
   {-# LINE 428 "src-ag/AG2AspectAG.ag" #-}
   rule178 = \ ((_lhsInewProds) ::  Map.Map ConstructorIdent FieldMap ) con_ ->
                                                     {-# LINE 428 "src-ag/AG2AspectAG.ag" #-}
                                                     Map.member con_ _lhsInewProds
                                                     {-# LINE 2214 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule179 #-}
   {-# LINE 430 "src-ag/AG2AspectAG.ag" #-}
   rule179 = \ ((_childrenIidCL) :: [(Identifier,Type)]) ((_childrenIppR) :: PP_Doc) ((_lhsIinhNoGroup) :: [String]) ((_lhsInewAtts) ::  Attributes ) ((_lhsInewNT) :: Bool) ((_lhsIppNt) :: PP_Doc) ((_lhsIsynNoGroup) :: [String]) _newProd _prodName ((_rulesIlocals) :: [Identifier]) ((_rulesIppRL) :: [ PPRule ]) con_ ->
                                {-# LINE 430 "src-ag/AG2AspectAG.ag" #-}
                                let  (instR, instRA)  = defInstRules  _lhsIppNt con_ _lhsInewNT _newProd
                                                                      _childrenIppR _rulesIppRL _childrenIidCL _rulesIlocals
                                     (locR,  locRA)   = defLocRule    _lhsIppNt con_ _lhsInewNT _newProd
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
                                     (inhGR, inhGRA)  = defInhGRule   _lhsIppNt _prodName     _lhsInewNT _newProd
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
                                     (synGR, synGRA)  = defSynGRule   _lhsIppNt con_ _lhsInewNT _newProd
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
                                     (inhR,  inhRA)   = defInhRules   _lhsIppNt _prodName     _lhsInewNT _newProd     _lhsInewAtts
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
                                     (synR,  synRA)   = defSynRules   _lhsIppNt con_ _lhsInewNT _newProd     _lhsInewAtts
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
                                     (inhMR,  inhMRA) = modInhRules   _lhsIppNt _prodName     _lhsInewNT _newProd     _lhsInewAtts
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup _childrenIidCL _rulesIlocals
                                     (synMR,  synMRA) = modSynRules   _lhsIppNt con_ _lhsInewNT _newProd     _lhsInewAtts
                                                                      _childrenIppR _rulesIppRL _lhsIinhNoGroup _lhsIsynNoGroup  _childrenIidCL _rulesIlocals
                                in   ( vlist [instR,locR,inhGR,synGR,inhR,synR,inhMR,synMR]
                                     , instRA ++ locRA ++ inhGRA ++ synGRA ++ inhMRA ++ synMRA ++ inhRA ++ synRA)
                                {-# LINE 2237 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule180 #-}
   {-# LINE 740 "src-ag/AG2AspectAG.ag" #-}
   rule180 = \ ((_lhsIext) :: Maybe String) ((_lhsInewNT) :: Bool) _newProd _ppRA _prodName macro_ ->
                                              {-# LINE 740 "src-ag/AG2AspectAG.ag" #-}
                                              let  extend = maybe  []
                                                                   (  \ext ->  if (_lhsInewNT || (not _lhsInewNT && _newProd    ))
                                                                               then []
                                                                               else [ ext >|< ".atts_" >|< _prodName     ])
                                                                   _lhsIext
                                                   macro  = case macro_ of
                                                                               Nothing ->  []
                                                                               Just macro ->  [ "agMacro " >|<  ppMacro macro  ]
                                                   atts = sortBy (\a b -> compare (show a) (show b)) _ppRA
                                              in   "atts_" >|< _prodName     >|< " = " >|<
                                                                                 ppListSep "" "" " `ext` "
                                                                                 (atts ++ macro ++ extend ) >-<
                                                   "semP_" >|< _prodName     >|< pp " = knit atts_" >|< _prodName
                                              {-# LINE 2255 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule181 #-}
   {-# LINE 804 "src-ag/AG2AspectAG.ag" #-}
   rule181 = \ ((_childrenIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) _conName ((_lhsIppNt) :: PP_Doc) _prodName con_ ->
                                              {-# LINE 804 "src-ag/AG2AspectAG.ag" #-}
                                              let  chi = _childrenIppCSF
                                                   ppPattern = case (show con_) of
                                                                "Cons"    -> ppParams (ppListSep "" "" " : ")
                                                                "Nil"     -> pp "[]"
                                                                otherwise -> _conName     >|< " " >|< (ppParams ppSpaced)
                                                   ppParams f =   f $ map (((>|<) (pp "_")) . fst) chi
                                              in   "sem_" >|< _lhsIppNt >|< " (" >|< ppPattern >|< ") = sem_" >|< _prodName     >|<
                                                   " (" >|< map (fst . snd) chi >|< "emptyRecord)"
                                              {-# LINE 2268 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule182 #-}
   {-# LINE 816 "src-ag/AG2AspectAG.ag" #-}
   rule182 = \ ((_childrenIppCSF) :: [(Identifier,(PP_Doc,PP_Doc))]) ((_lhsIppNt) :: PP_Doc) _prodName con_ ->
                                              {-# LINE 816 "src-ag/AG2AspectAG.ag" #-}
                                              let  chi = _childrenIppCSF
                                                   ppParams f =   f $ map (((>|<) (pp "_")) . fst) chi
                                              in   "sem_" >|< _lhsIppNt >|< "_" >|< con_ >#< ppParams ppSpaced >|< " = semP_" >|< _prodName     >|<
                                                   " (" >|< map (snd . snd) chi >|< "emptyRecord)"
                                              {-# LINE 2277 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule183 #-}
   rule183 = \  (_ :: ()) ->
     []
   {-# INLINE rule184 #-}
   rule184 = \ _ppR ->
     _ppR
   {-# INLINE rule185 #-}
   rule185 = \ _ppRA ->
     _ppRA
   {-# INLINE rule186 #-}
   rule186 = \ ((_childrenIprdInh) :: Attributes) ->
     _childrenIprdInh
   {-# INLINE rule187 #-}
   rule187 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule188 #-}
   rule188 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule189 #-}
   rule189 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule190 #-}
   rule190 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule191 #-}
   rule191 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule192 #-}
   rule192 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule193 #-}
   rule193 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule194 #-}
   rule194 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule195 #-}
   rule195 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
   {-# INLINE rule196 #-}
   rule196 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule197 #-}
   rule197 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule198 #-}
   rule198 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule199 #-}
   rule199 = \ _newProd ->
     _newProd
   {-# INLINE rule200 #-}
   rule200 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule201 #-}
   rule201 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule202 #-}
   rule202 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup

-- Productions -------------------------------------------------
-- wrapper
data Inh_Productions  = Inh_Productions { ext_Inh_Productions :: (Maybe String), inh_Inh_Productions :: ( Attributes ), inhMap_Inh_Productions :: (Map Identifier Attributes), inhNoGroup_Inh_Productions :: ([String]), newAtts_Inh_Productions :: ( Attributes ), newNT_Inh_Productions :: (Bool), newProds_Inh_Productions :: ( Map.Map ConstructorIdent FieldMap ), o_noGroup_Inh_Productions :: ([String]), o_rename_Inh_Productions :: (Bool), ppNt_Inh_Productions :: (PP_Doc), syn_Inh_Productions :: ( Attributes ), synMap_Inh_Productions :: (Map Identifier Attributes), synNoGroup_Inh_Productions :: ([String]) }
data Syn_Productions  = Syn_Productions { hasMoreProds_Syn_Productions :: ( Bool ), ppA_Syn_Productions :: (PP_Doc), ppCata_Syn_Productions :: (PP_Doc), ppDL_Syn_Productions :: ([PP_Doc]), ppL_Syn_Productions :: (PP_Doc), ppLI_Syn_Productions :: ([PP_Doc]), ppR_Syn_Productions :: (PP_Doc), ppRA_Syn_Productions :: ([PP_Doc]), ppSF_Syn_Productions :: (PP_Doc), ppSPF_Syn_Productions :: (PP_Doc), prdInh_Syn_Productions :: (Attributes) }
{-# INLINABLE wrap_Productions #-}
wrap_Productions :: T_Productions  -> Inh_Productions  -> (Syn_Productions )
wrap_Productions (T_Productions act) (Inh_Productions _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg37 = T_Productions_vIn37 _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup
        (T_Productions_vOut37 _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh) <- return (inv_Productions_s38 sem arg37)
        return (Syn_Productions _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh)
   )

-- cata
{-# NOINLINE sem_Productions #-}
sem_Productions :: Productions  -> T_Productions 
sem_Productions list = Prelude.foldr sem_Productions_Cons sem_Productions_Nil (Prelude.map sem_Production list)

-- semantic domain
newtype T_Productions  = T_Productions {
                                       attach_T_Productions :: Identity (T_Productions_s38 )
                                       }
newtype T_Productions_s38  = C_Productions_s38 {
                                               inv_Productions_s38 :: (T_Productions_v37 )
                                               }
data T_Productions_s39  = C_Productions_s39
type T_Productions_v37  = (T_Productions_vIn37 ) -> (T_Productions_vOut37 )
data T_Productions_vIn37  = T_Productions_vIn37 (Maybe String) ( Attributes ) (Map Identifier Attributes) ([String]) ( Attributes ) (Bool) ( Map.Map ConstructorIdent FieldMap ) ([String]) (Bool) (PP_Doc) ( Attributes ) (Map Identifier Attributes) ([String])
data T_Productions_vOut37  = T_Productions_vOut37 ( Bool ) (PP_Doc) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) ([PP_Doc]) (PP_Doc) (PP_Doc) (Attributes)
{-# NOINLINE sem_Productions_Cons #-}
sem_Productions_Cons :: T_Production  -> T_Productions  -> T_Productions 
sem_Productions_Cons arg_hd_ arg_tl_ = T_Productions (return st38) where
   {-# NOINLINE st38 #-}
   st38 = let
      v37 :: T_Productions_v37 
      v37 = \ (T_Productions_vIn37 _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup) -> ( let
         _hdX35 = Control.Monad.Identity.runIdentity (attach_T_Production (arg_hd_))
         _tlX38 = Control.Monad.Identity.runIdentity (attach_T_Productions (arg_tl_))
         (T_Production_vOut34 _hdIhasMoreProds _hdIppA _hdIppCata _hdIppD _hdIppDI _hdIppL _hdIppLI _hdIppR _hdIppRA _hdIppSF _hdIppSPF _hdIprdInh) = inv_Production_s35 _hdX35 (T_Production_vIn34 _hdOext _hdOinh _hdOinhMap _hdOinhNoGroup _hdOnewAtts _hdOnewNT _hdOnewProds _hdOo_noGroup _hdOo_rename _hdOppNt _hdOsyn _hdOsynMap _hdOsynNoGroup)
         (T_Productions_vOut37 _tlIhasMoreProds _tlIppA _tlIppCata _tlIppDL _tlIppL _tlIppLI _tlIppR _tlIppRA _tlIppSF _tlIppSPF _tlIprdInh) = inv_Productions_s38 _tlX38 (T_Productions_vIn37 _tlOext _tlOinh _tlOinhMap _tlOinhNoGroup _tlOnewAtts _tlOnewNT _tlOnewProds _tlOo_noGroup _tlOo_rename _tlOppNt _tlOsyn _tlOsynMap _tlOsynNoGroup)
         _hdOinhNoGroup = rule203 _hdIprdInh _lhsIinhNoGroup
         _lhsOppDL :: [PP_Doc]
         _lhsOppDL = rule204 _hdIppD _tlIppDL
         _lhsOhasMoreProds ::  Bool 
         _lhsOhasMoreProds = rule205 _hdIhasMoreProds _tlIhasMoreProds
         _lhsOppA :: PP_Doc
         _lhsOppA = rule206 _hdIppA _tlIppA
         _lhsOppCata :: PP_Doc
         _lhsOppCata = rule207 _hdIppCata _tlIppCata
         _lhsOppL :: PP_Doc
         _lhsOppL = rule208 _hdIppL _tlIppL
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule209 _hdIppLI _tlIppLI
         _lhsOppR :: PP_Doc
         _lhsOppR = rule210 _hdIppR _tlIppR
         _lhsOppRA :: [PP_Doc]
         _lhsOppRA = rule211 _hdIppRA _tlIppRA
         _lhsOppSF :: PP_Doc
         _lhsOppSF = rule212 _hdIppSF _tlIppSF
         _lhsOppSPF :: PP_Doc
         _lhsOppSPF = rule213 _hdIppSPF _tlIppSPF
         _lhsOprdInh :: Attributes
         _lhsOprdInh = rule214 _hdIprdInh _tlIprdInh
         _hdOext = rule215 _lhsIext
         _hdOinh = rule216 _lhsIinh
         _hdOinhMap = rule217 _lhsIinhMap
         _hdOnewAtts = rule218 _lhsInewAtts
         _hdOnewNT = rule219 _lhsInewNT
         _hdOnewProds = rule220 _lhsInewProds
         _hdOo_noGroup = rule221 _lhsIo_noGroup
         _hdOo_rename = rule222 _lhsIo_rename
         _hdOppNt = rule223 _lhsIppNt
         _hdOsyn = rule224 _lhsIsyn
         _hdOsynMap = rule225 _lhsIsynMap
         _hdOsynNoGroup = rule226 _lhsIsynNoGroup
         _tlOext = rule227 _lhsIext
         _tlOinh = rule228 _lhsIinh
         _tlOinhMap = rule229 _lhsIinhMap
         _tlOinhNoGroup = rule230 _lhsIinhNoGroup
         _tlOnewAtts = rule231 _lhsInewAtts
         _tlOnewNT = rule232 _lhsInewNT
         _tlOnewProds = rule233 _lhsInewProds
         _tlOo_noGroup = rule234 _lhsIo_noGroup
         _tlOo_rename = rule235 _lhsIo_rename
         _tlOppNt = rule236 _lhsIppNt
         _tlOsyn = rule237 _lhsIsyn
         _tlOsynMap = rule238 _lhsIsynMap
         _tlOsynNoGroup = rule239 _lhsIsynNoGroup
         __result_ = T_Productions_vOut37 _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh
         in __result_ )
     in C_Productions_s38 v37
   {-# INLINE rule203 #-}
   {-# LINE 62 "src-ag/AG2AspectAG.ag" #-}
   rule203 = \ ((_hdIprdInh) :: Attributes) ((_lhsIinhNoGroup) :: [String]) ->
                                {-# LINE 62 "src-ag/AG2AspectAG.ag" #-}
                                filter (flip Map.member _hdIprdInh . identifier) _lhsIinhNoGroup
                                {-# LINE 2436 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule204 #-}
   {-# LINE 234 "src-ag/AG2AspectAG.ag" #-}
   rule204 = \ ((_hdIppD) :: PP_Doc) ((_tlIppDL) :: [PP_Doc]) ->
                                                                                  {-# LINE 234 "src-ag/AG2AspectAG.ag" #-}
                                                                                  _hdIppD : _tlIppDL
                                                                                  {-# LINE 2442 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule205 #-}
   rule205 = \ ((_hdIhasMoreProds) ::  Bool ) ((_tlIhasMoreProds) ::  Bool ) ->
     _hdIhasMoreProds  ||  _tlIhasMoreProds
   {-# INLINE rule206 #-}
   rule206 = \ ((_hdIppA) :: PP_Doc) ((_tlIppA) :: PP_Doc) ->
     _hdIppA >-< _tlIppA
   {-# INLINE rule207 #-}
   rule207 = \ ((_hdIppCata) :: PP_Doc) ((_tlIppCata) :: PP_Doc) ->
     _hdIppCata >-< _tlIppCata
   {-# INLINE rule208 #-}
   rule208 = \ ((_hdIppL) :: PP_Doc) ((_tlIppL) :: PP_Doc) ->
     _hdIppL >-< _tlIppL
   {-# INLINE rule209 #-}
   rule209 = \ ((_hdIppLI) :: [PP_Doc]) ((_tlIppLI) :: [PP_Doc]) ->
     _hdIppLI ++ _tlIppLI
   {-# INLINE rule210 #-}
   rule210 = \ ((_hdIppR) :: PP_Doc) ((_tlIppR) :: PP_Doc) ->
     _hdIppR >-< _tlIppR
   {-# INLINE rule211 #-}
   rule211 = \ ((_hdIppRA) :: [PP_Doc]) ((_tlIppRA) :: [PP_Doc]) ->
     _hdIppRA ++ _tlIppRA
   {-# INLINE rule212 #-}
   rule212 = \ ((_hdIppSF) :: PP_Doc) ((_tlIppSF) :: PP_Doc) ->
     _hdIppSF >-< _tlIppSF
   {-# INLINE rule213 #-}
   rule213 = \ ((_hdIppSPF) :: PP_Doc) ((_tlIppSPF) :: PP_Doc) ->
     _hdIppSPF >-< _tlIppSPF
   {-# INLINE rule214 #-}
   rule214 = \ ((_hdIprdInh) :: Attributes) ((_tlIprdInh) :: Attributes) ->
     _hdIprdInh `Map.union` _tlIprdInh
   {-# INLINE rule215 #-}
   rule215 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule216 #-}
   rule216 = \ ((_lhsIinh) ::  Attributes ) ->
     _lhsIinh
   {-# INLINE rule217 #-}
   rule217 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule218 #-}
   rule218 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule219 #-}
   rule219 = \ ((_lhsInewNT) :: Bool) ->
     _lhsInewNT
   {-# INLINE rule220 #-}
   rule220 = \ ((_lhsInewProds) ::  Map.Map ConstructorIdent FieldMap ) ->
     _lhsInewProds
   {-# INLINE rule221 #-}
   rule221 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule222 #-}
   rule222 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule223 #-}
   rule223 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule224 #-}
   rule224 = \ ((_lhsIsyn) ::  Attributes ) ->
     _lhsIsyn
   {-# INLINE rule225 #-}
   rule225 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule226 #-}
   rule226 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
   {-# INLINE rule227 #-}
   rule227 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule228 #-}
   rule228 = \ ((_lhsIinh) ::  Attributes ) ->
     _lhsIinh
   {-# INLINE rule229 #-}
   rule229 = \ ((_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# INLINE rule230 #-}
   rule230 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule231 #-}
   rule231 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule232 #-}
   rule232 = \ ((_lhsInewNT) :: Bool) ->
     _lhsInewNT
   {-# INLINE rule233 #-}
   rule233 = \ ((_lhsInewProds) ::  Map.Map ConstructorIdent FieldMap ) ->
     _lhsInewProds
   {-# INLINE rule234 #-}
   rule234 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule235 #-}
   rule235 = \ ((_lhsIo_rename) :: Bool) ->
     _lhsIo_rename
   {-# INLINE rule236 #-}
   rule236 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule237 #-}
   rule237 = \ ((_lhsIsyn) ::  Attributes ) ->
     _lhsIsyn
   {-# INLINE rule238 #-}
   rule238 = \ ((_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# INLINE rule239 #-}
   rule239 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
{-# NOINLINE sem_Productions_Nil #-}
sem_Productions_Nil ::  T_Productions 
sem_Productions_Nil  = T_Productions (return st38) where
   {-# NOINLINE st38 #-}
   st38 = let
      v37 :: T_Productions_v37 
      v37 = \ (T_Productions_vIn37 _lhsIext _lhsIinh _lhsIinhMap _lhsIinhNoGroup _lhsInewAtts _lhsInewNT _lhsInewProds _lhsIo_noGroup _lhsIo_rename _lhsIppNt _lhsIsyn _lhsIsynMap _lhsIsynNoGroup) -> ( let
         _lhsOppDL :: [PP_Doc]
         _lhsOppDL = rule240  ()
         _lhsOhasMoreProds ::  Bool 
         _lhsOhasMoreProds = rule241  ()
         _lhsOppA :: PP_Doc
         _lhsOppA = rule242  ()
         _lhsOppCata :: PP_Doc
         _lhsOppCata = rule243  ()
         _lhsOppL :: PP_Doc
         _lhsOppL = rule244  ()
         _lhsOppLI :: [PP_Doc]
         _lhsOppLI = rule245  ()
         _lhsOppR :: PP_Doc
         _lhsOppR = rule246  ()
         _lhsOppRA :: [PP_Doc]
         _lhsOppRA = rule247  ()
         _lhsOppSF :: PP_Doc
         _lhsOppSF = rule248  ()
         _lhsOppSPF :: PP_Doc
         _lhsOppSPF = rule249  ()
         _lhsOprdInh :: Attributes
         _lhsOprdInh = rule250  ()
         __result_ = T_Productions_vOut37 _lhsOhasMoreProds _lhsOppA _lhsOppCata _lhsOppDL _lhsOppL _lhsOppLI _lhsOppR _lhsOppRA _lhsOppSF _lhsOppSPF _lhsOprdInh
         in __result_ )
     in C_Productions_s38 v37
   {-# INLINE rule240 #-}
   {-# LINE 235 "src-ag/AG2AspectAG.ag" #-}
   rule240 = \  (_ :: ()) ->
                                                                                  {-# LINE 235 "src-ag/AG2AspectAG.ag" #-}
                                                                                  []
                                                                                  {-# LINE 2585 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule241 #-}
   rule241 = \  (_ :: ()) ->
     False
   {-# INLINE rule242 #-}
   rule242 = \  (_ :: ()) ->
     empty
   {-# INLINE rule243 #-}
   rule243 = \  (_ :: ()) ->
     empty
   {-# INLINE rule244 #-}
   rule244 = \  (_ :: ()) ->
     empty
   {-# INLINE rule245 #-}
   rule245 = \  (_ :: ()) ->
     []
   {-# INLINE rule246 #-}
   rule246 = \  (_ :: ()) ->
     empty
   {-# INLINE rule247 #-}
   rule247 = \  (_ :: ()) ->
     []
   {-# INLINE rule248 #-}
   rule248 = \  (_ :: ()) ->
     empty
   {-# INLINE rule249 #-}
   rule249 = \  (_ :: ()) ->
     empty
   {-# INLINE rule250 #-}
   rule250 = \  (_ :: ()) ->
     Map.empty

-- Rule --------------------------------------------------------
-- wrapper
data Inh_Rule  = Inh_Rule { ext_Inh_Rule :: (Maybe String), inhNoGroup_Inh_Rule :: ([String]), newAtts_Inh_Rule :: ( Attributes ), newProd_Inh_Rule :: (Bool), o_noGroup_Inh_Rule :: ([String]), ppNt_Inh_Rule :: (PP_Doc), ppProd_Inh_Rule :: (PP_Doc), synNoGroup_Inh_Rule :: ([String]) }
data Syn_Rule  = Syn_Rule { locals_Syn_Rule :: ([Identifier]), ppRL_Syn_Rule :: ([ PPRule ]) }
{-# INLINABLE wrap_Rule #-}
wrap_Rule :: T_Rule  -> Inh_Rule  -> (Syn_Rule )
wrap_Rule (T_Rule act) (Inh_Rule _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg40 = T_Rule_vIn40 _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup
        (T_Rule_vOut40 _lhsOlocals _lhsOppRL) <- return (inv_Rule_s41 sem arg40)
        return (Syn_Rule _lhsOlocals _lhsOppRL)
   )

-- cata
{-# INLINE sem_Rule #-}
sem_Rule :: Rule  -> T_Rule 
sem_Rule ( Rule mbName_ pattern_ rhs_ owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_ ) = sem_Rule_Rule mbName_ ( sem_Pattern pattern_ ) ( sem_Expression rhs_ ) owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_

-- semantic domain
newtype T_Rule  = T_Rule {
                         attach_T_Rule :: Identity (T_Rule_s41 )
                         }
newtype T_Rule_s41  = C_Rule_s41 {
                                 inv_Rule_s41 :: (T_Rule_v40 )
                                 }
data T_Rule_s42  = C_Rule_s42
type T_Rule_v40  = (T_Rule_vIn40 ) -> (T_Rule_vOut40 )
data T_Rule_vIn40  = T_Rule_vIn40 (Maybe String) ([String]) ( Attributes ) (Bool) ([String]) (PP_Doc) (PP_Doc) ([String])
data T_Rule_vOut40  = T_Rule_vOut40 ([Identifier]) ([ PPRule ])
{-# NOINLINE sem_Rule_Rule #-}
sem_Rule_Rule :: (Maybe Identifier) -> T_Pattern  -> T_Expression  -> (Bool) -> (String) -> (Bool) -> (Bool) -> (Bool) -> (Maybe Error) -> (Bool) -> T_Rule 
sem_Rule_Rule _ arg_pattern_ arg_rhs_ arg_owrt_ _ arg_explicit_ _ _ _ _ = T_Rule (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Rule_v40 
      v40 = \ (T_Rule_vIn40 _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup) -> ( let
         _patternX29 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         _rhsX8 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_rhs_))
         (T_Pattern_vOut28 _patternIcopy _patternIinfo) = inv_Pattern_s29 _patternX29 (T_Pattern_vIn28 )
         (T_Expression_vOut7 _rhsIppRE) = inv_Expression_s8 _rhsX8 (T_Expression_vIn7 _rhsOppNt _rhsOppProd)
         _lhsOlocals :: [Identifier]
         _lhsOlocals = rule251 _patternIinfo
         _lhsOppRL :: [ PPRule ]
         _lhsOppRL = rule252 _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _patternIinfo _rhsIppRE arg_explicit_ arg_owrt_
         _rhsOppNt = rule253 _lhsIppNt
         _rhsOppProd = rule254 _lhsIppProd
         __result_ = T_Rule_vOut40 _lhsOlocals _lhsOppRL
         in __result_ )
     in C_Rule_s41 v40
   {-# INLINE rule251 #-}
   {-# LINE 375 "src-ag/AG2AspectAG.ag" #-}
   rule251 = \ ((_patternIinfo) :: (Identifier, Identifier)) ->
                                                       {-# LINE 375 "src-ag/AG2AspectAG.ag" #-}
                                                       if (show (fst _patternIinfo) == "loc")
                                                        then [ snd _patternIinfo ]
                                                        else [ ]
                                                       {-# LINE 2674 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule252 #-}
   {-# LINE 472 "src-ag/AG2AspectAG.ag" #-}
   rule252 = \ ((_lhsInewAtts) ::  Attributes ) ((_lhsInewProd) :: Bool) ((_lhsIo_noGroup) :: [String]) ((_lhsIppNt) :: PP_Doc) ((_patternIinfo) :: (Identifier, Identifier)) ((_rhsIppRE) :: [String] -> Identifier -> [(Identifier,Type)] -> [Identifier] -> PP_Doc) explicit_ owrt_ ->
                                                                             {-# LINE 472 "src-ag/AG2AspectAG.ag" #-}
                                                                             if (not explicit_ &&  not _lhsInewProd && not (Map.member (snd _patternIinfo) _lhsInewAtts) )
                                                                             then []
                                                                             else [ ppRule _patternIinfo owrt_ (defRule _lhsIppNt _patternIinfo _lhsIo_noGroup _rhsIppRE) ]
                                                                             {-# LINE 2682 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule253 #-}
   rule253 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule254 #-}
   rule254 = \ ((_lhsIppProd) :: PP_Doc) ->
     _lhsIppProd

-- Rules -------------------------------------------------------
-- wrapper
data Inh_Rules  = Inh_Rules { ext_Inh_Rules :: (Maybe String), inhNoGroup_Inh_Rules :: ([String]), newAtts_Inh_Rules :: ( Attributes ), newProd_Inh_Rules :: (Bool), o_noGroup_Inh_Rules :: ([String]), ppNt_Inh_Rules :: (PP_Doc), ppProd_Inh_Rules :: (PP_Doc), synNoGroup_Inh_Rules :: ([String]) }
data Syn_Rules  = Syn_Rules { locals_Syn_Rules :: ([Identifier]), ppRL_Syn_Rules :: ([ PPRule ]) }
{-# INLINABLE wrap_Rules #-}
wrap_Rules :: T_Rules  -> Inh_Rules  -> (Syn_Rules )
wrap_Rules (T_Rules act) (Inh_Rules _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg43 = T_Rules_vIn43 _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup
        (T_Rules_vOut43 _lhsOlocals _lhsOppRL) <- return (inv_Rules_s44 sem arg43)
        return (Syn_Rules _lhsOlocals _lhsOppRL)
   )

-- cata
{-# NOINLINE sem_Rules #-}
sem_Rules :: Rules  -> T_Rules 
sem_Rules list = Prelude.foldr sem_Rules_Cons sem_Rules_Nil (Prelude.map sem_Rule list)

-- semantic domain
newtype T_Rules  = T_Rules {
                           attach_T_Rules :: Identity (T_Rules_s44 )
                           }
newtype T_Rules_s44  = C_Rules_s44 {
                                   inv_Rules_s44 :: (T_Rules_v43 )
                                   }
data T_Rules_s45  = C_Rules_s45
type T_Rules_v43  = (T_Rules_vIn43 ) -> (T_Rules_vOut43 )
data T_Rules_vIn43  = T_Rules_vIn43 (Maybe String) ([String]) ( Attributes ) (Bool) ([String]) (PP_Doc) (PP_Doc) ([String])
data T_Rules_vOut43  = T_Rules_vOut43 ([Identifier]) ([ PPRule ])
{-# NOINLINE sem_Rules_Cons #-}
sem_Rules_Cons :: T_Rule  -> T_Rules  -> T_Rules 
sem_Rules_Cons arg_hd_ arg_tl_ = T_Rules (return st44) where
   {-# NOINLINE st44 #-}
   st44 = let
      v43 :: T_Rules_v43 
      v43 = \ (T_Rules_vIn43 _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup) -> ( let
         _hdX41 = Control.Monad.Identity.runIdentity (attach_T_Rule (arg_hd_))
         _tlX44 = Control.Monad.Identity.runIdentity (attach_T_Rules (arg_tl_))
         (T_Rule_vOut40 _hdIlocals _hdIppRL) = inv_Rule_s41 _hdX41 (T_Rule_vIn40 _hdOext _hdOinhNoGroup _hdOnewAtts _hdOnewProd _hdOo_noGroup _hdOppNt _hdOppProd _hdOsynNoGroup)
         (T_Rules_vOut43 _tlIlocals _tlIppRL) = inv_Rules_s44 _tlX44 (T_Rules_vIn43 _tlOext _tlOinhNoGroup _tlOnewAtts _tlOnewProd _tlOo_noGroup _tlOppNt _tlOppProd _tlOsynNoGroup)
         _lhsOppRL :: [ PPRule ]
         _lhsOppRL = rule255 _hdIppRL _tlIppRL
         _lhsOlocals :: [Identifier]
         _lhsOlocals = rule256 _hdIlocals _tlIlocals
         _hdOext = rule257 _lhsIext
         _hdOinhNoGroup = rule258 _lhsIinhNoGroup
         _hdOnewAtts = rule259 _lhsInewAtts
         _hdOnewProd = rule260 _lhsInewProd
         _hdOo_noGroup = rule261 _lhsIo_noGroup
         _hdOppNt = rule262 _lhsIppNt
         _hdOppProd = rule263 _lhsIppProd
         _hdOsynNoGroup = rule264 _lhsIsynNoGroup
         _tlOext = rule265 _lhsIext
         _tlOinhNoGroup = rule266 _lhsIinhNoGroup
         _tlOnewAtts = rule267 _lhsInewAtts
         _tlOnewProd = rule268 _lhsInewProd
         _tlOo_noGroup = rule269 _lhsIo_noGroup
         _tlOppNt = rule270 _lhsIppNt
         _tlOppProd = rule271 _lhsIppProd
         _tlOsynNoGroup = rule272 _lhsIsynNoGroup
         __result_ = T_Rules_vOut43 _lhsOlocals _lhsOppRL
         in __result_ )
     in C_Rules_s44 v43
   {-# INLINE rule255 #-}
   {-# LINE 468 "src-ag/AG2AspectAG.ag" #-}
   rule255 = \ ((_hdIppRL) :: [ PPRule ]) ((_tlIppRL) :: [ PPRule ]) ->
                                                                                  {-# LINE 468 "src-ag/AG2AspectAG.ag" #-}
                                                                                  _hdIppRL ++ _tlIppRL
                                                                                  {-# LINE 2759 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule256 #-}
   rule256 = \ ((_hdIlocals) :: [Identifier]) ((_tlIlocals) :: [Identifier]) ->
     _hdIlocals ++ _tlIlocals
   {-# INLINE rule257 #-}
   rule257 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule258 #-}
   rule258 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule259 #-}
   rule259 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule260 #-}
   rule260 = \ ((_lhsInewProd) :: Bool) ->
     _lhsInewProd
   {-# INLINE rule261 #-}
   rule261 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule262 #-}
   rule262 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule263 #-}
   rule263 = \ ((_lhsIppProd) :: PP_Doc) ->
     _lhsIppProd
   {-# INLINE rule264 #-}
   rule264 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
   {-# INLINE rule265 #-}
   rule265 = \ ((_lhsIext) :: Maybe String) ->
     _lhsIext
   {-# INLINE rule266 #-}
   rule266 = \ ((_lhsIinhNoGroup) :: [String]) ->
     _lhsIinhNoGroup
   {-# INLINE rule267 #-}
   rule267 = \ ((_lhsInewAtts) ::  Attributes ) ->
     _lhsInewAtts
   {-# INLINE rule268 #-}
   rule268 = \ ((_lhsInewProd) :: Bool) ->
     _lhsInewProd
   {-# INLINE rule269 #-}
   rule269 = \ ((_lhsIo_noGroup) :: [String]) ->
     _lhsIo_noGroup
   {-# INLINE rule270 #-}
   rule270 = \ ((_lhsIppNt) :: PP_Doc) ->
     _lhsIppNt
   {-# INLINE rule271 #-}
   rule271 = \ ((_lhsIppProd) :: PP_Doc) ->
     _lhsIppProd
   {-# INLINE rule272 #-}
   rule272 = \ ((_lhsIsynNoGroup) :: [String]) ->
     _lhsIsynNoGroup
{-# NOINLINE sem_Rules_Nil #-}
sem_Rules_Nil ::  T_Rules 
sem_Rules_Nil  = T_Rules (return st44) where
   {-# NOINLINE st44 #-}
   st44 = let
      v43 :: T_Rules_v43 
      v43 = \ (T_Rules_vIn43 _lhsIext _lhsIinhNoGroup _lhsInewAtts _lhsInewProd _lhsIo_noGroup _lhsIppNt _lhsIppProd _lhsIsynNoGroup) -> ( let
         _lhsOppRL :: [ PPRule ]
         _lhsOppRL = rule273  ()
         _lhsOlocals :: [Identifier]
         _lhsOlocals = rule274  ()
         __result_ = T_Rules_vOut43 _lhsOlocals _lhsOppRL
         in __result_ )
     in C_Rules_s44 v43
   {-# INLINE rule273 #-}
   {-# LINE 469 "src-ag/AG2AspectAG.ag" #-}
   rule273 = \  (_ :: ()) ->
                                                                                  {-# LINE 469 "src-ag/AG2AspectAG.ag" #-}
                                                                                  []
                                                                                  {-# LINE 2830 "src-generated/AG2AspectAG.hs" #-}
   {-# INLINE rule274 #-}
   rule274 = \  (_ :: ()) ->
     []

-- TypeSig -----------------------------------------------------
-- wrapper
data Inh_TypeSig  = Inh_TypeSig {  }
data Syn_TypeSig  = Syn_TypeSig {  }
{-# INLINABLE wrap_TypeSig #-}
wrap_TypeSig :: T_TypeSig  -> Inh_TypeSig  -> (Syn_TypeSig )
wrap_TypeSig (T_TypeSig act) (Inh_TypeSig ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg46 = T_TypeSig_vIn46 
        (T_TypeSig_vOut46 ) <- return (inv_TypeSig_s47 sem arg46)
        return (Syn_TypeSig )
   )

-- cata
{-# INLINE sem_TypeSig #-}
sem_TypeSig :: TypeSig  -> T_TypeSig 
sem_TypeSig ( TypeSig name_ tp_ ) = sem_TypeSig_TypeSig name_ tp_

-- semantic domain
newtype T_TypeSig  = T_TypeSig {
                               attach_T_TypeSig :: Identity (T_TypeSig_s47 )
                               }
newtype T_TypeSig_s47  = C_TypeSig_s47 {
                                       inv_TypeSig_s47 :: (T_TypeSig_v46 )
                                       }
data T_TypeSig_s48  = C_TypeSig_s48
type T_TypeSig_v46  = (T_TypeSig_vIn46 ) -> (T_TypeSig_vOut46 )
data T_TypeSig_vIn46  = T_TypeSig_vIn46 
data T_TypeSig_vOut46  = T_TypeSig_vOut46 
{-# NOINLINE sem_TypeSig_TypeSig #-}
sem_TypeSig_TypeSig :: (Identifier) -> (Type) -> T_TypeSig 
sem_TypeSig_TypeSig _ _ = T_TypeSig (return st47) where
   {-# NOINLINE st47 #-}
   st47 = let
      v46 :: T_TypeSig_v46 
      v46 = \ (T_TypeSig_vIn46 ) -> ( let
         __result_ = T_TypeSig_vOut46 
         in __result_ )
     in C_TypeSig_s47 v46

-- TypeSigs ----------------------------------------------------
-- wrapper
data Inh_TypeSigs  = Inh_TypeSigs {  }
data Syn_TypeSigs  = Syn_TypeSigs {  }
{-# INLINABLE wrap_TypeSigs #-}
wrap_TypeSigs :: T_TypeSigs  -> Inh_TypeSigs  -> (Syn_TypeSigs )
wrap_TypeSigs (T_TypeSigs act) (Inh_TypeSigs ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg49 = T_TypeSigs_vIn49 
        (T_TypeSigs_vOut49 ) <- return (inv_TypeSigs_s50 sem arg49)
        return (Syn_TypeSigs )
   )

-- cata
{-# NOINLINE sem_TypeSigs #-}
sem_TypeSigs :: TypeSigs  -> T_TypeSigs 
sem_TypeSigs list = Prelude.foldr sem_TypeSigs_Cons sem_TypeSigs_Nil (Prelude.map sem_TypeSig list)

-- semantic domain
newtype T_TypeSigs  = T_TypeSigs {
                                 attach_T_TypeSigs :: Identity (T_TypeSigs_s50 )
                                 }
newtype T_TypeSigs_s50  = C_TypeSigs_s50 {
                                         inv_TypeSigs_s50 :: (T_TypeSigs_v49 )
                                         }
data T_TypeSigs_s51  = C_TypeSigs_s51
type T_TypeSigs_v49  = (T_TypeSigs_vIn49 ) -> (T_TypeSigs_vOut49 )
data T_TypeSigs_vIn49  = T_TypeSigs_vIn49 
data T_TypeSigs_vOut49  = T_TypeSigs_vOut49 
{-# NOINLINE sem_TypeSigs_Cons #-}
sem_TypeSigs_Cons :: T_TypeSig  -> T_TypeSigs  -> T_TypeSigs 
sem_TypeSigs_Cons arg_hd_ arg_tl_ = T_TypeSigs (return st50) where
   {-# NOINLINE st50 #-}
   st50 = let
      v49 :: T_TypeSigs_v49 
      v49 = \ (T_TypeSigs_vIn49 ) -> ( let
         _hdX47 = Control.Monad.Identity.runIdentity (attach_T_TypeSig (arg_hd_))
         _tlX50 = Control.Monad.Identity.runIdentity (attach_T_TypeSigs (arg_tl_))
         (T_TypeSig_vOut46 ) = inv_TypeSig_s47 _hdX47 (T_TypeSig_vIn46 )
         (T_TypeSigs_vOut49 ) = inv_TypeSigs_s50 _tlX50 (T_TypeSigs_vIn49 )
         __result_ = T_TypeSigs_vOut49 
         in __result_ )
     in C_TypeSigs_s50 v49
{-# NOINLINE sem_TypeSigs_Nil #-}
sem_TypeSigs_Nil ::  T_TypeSigs 
sem_TypeSigs_Nil  = T_TypeSigs (return st50) where
   {-# NOINLINE st50 #-}
   st50 = let
      v49 :: T_TypeSigs_v49 
      v49 = \ (T_TypeSigs_vIn49 ) -> ( let
         __result_ = T_TypeSigs_vOut49 
         in __result_ )
     in C_TypeSigs_s50 v49
