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

module LOAG.Order where

{-# LINE 10 "src-ag/LOAG/Rep.ag" #-}

import Data.List (intercalate, foldl', nub)
import Data.Tuple (swap)
import Control.Arrow
{-# LINE 12 "src-generated/LOAG/Order.hs" #-}

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

import CommonTypes
import UU.Scanner.Position(Pos)
{-# LINE 18 "src-generated/LOAG/Order.hs" #-}

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

import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 24 "src-generated/LOAG/Order.hs" #-}

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

import Patterns
import CommonTypes
import Data.Map(Map)
import Data.Set(Set)
{-# LINE 32 "src-generated/LOAG/Order.hs" #-}

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

-- Patterns.ag imports
import UU.Scanner.Position(Pos)
import CommonTypes (ConstructorIdent,Identifier)
{-# LINE 39 "src-generated/LOAG/Order.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 51 "src-generated/LOAG/Order.hs" #-}

{-# LINE 13 "src-ag/LOAG/Order.ag" #-}

import qualified Data.Array as A
import qualified Data.Map as Map
import qualified Data.IntMap as IMap
import qualified Data.Set as Set
import qualified Data.IntSet as IS
import qualified Data.Sequence as Seq
import qualified CommonTypes as CT
import Control.Monad (forM,when)
import Control.Monad.ST
import Data.Maybe(catMaybes)
import Data.Monoid(mappend,mempty)
import Data.STRef
import AbstractSyntax
import qualified LOAG.AOAG as   AOAG
import LOAG.Common
import LOAG.Chordal
import LOAG.Rep
import LOAG.Graphs
import CodeSyntax
import Data.Maybe (isJust, fromJust)
import ExecutionPlan
import GrammarInfo
import HsToken (HsToken(..))
import Pretty
import qualified System.IO as IO
import           System.IO.Unsafe
{-# LINE 81 "src-generated/LOAG/Order.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 13 "src-ag/LOAG/Prepare.ag" #-}

-- | Translating UUAGC types to MyTypes
drhs f | f == _LHS               = Inh
       | f == _LOC               = AnyDir
       | f == _INST              = AnyDir
       | otherwise               = Syn
dlhs f | f == _LHS               = Syn
       | f == _LOC               = AnyDir
       | f == _INST              = AnyDir
       | otherwise               = Inh 

depToEdge :: PMP_R -> PLabel -> Dependency -> Edge
depToEdge pmpr p e = 
    (findWithErr pmpr "depToEdge" $ MyOccurrence (p,getName f1) (getName i1, drhs f1),
     findWithErr pmpr "depToEdge" $ MyOccurrence (p,getName f2) (getName i2, dlhs f2))
    where Dependency (OccAttr f1 i1) (OccAttr f2 i2) = e

vertexToAttr :: NMP -> Vertex -> Attributes
vertexToAttr nmp v = Map.singleton (identifier a) (fromMyTy ty)
    where (MyAttribute ty (a,_)) = findWithErr nmp "vertexToAttr" v

{-# LINE 106 "src-generated/LOAG/Order.hs" #-}

{-# LINE 292 "src-ag/LOAG/Prepare.ag" #-}

-- | Replace the references to local attributes, by his attrs dependencies,
-- |    rendering the local attributes 'transparent'.
repLocRefs :: SF_P -> SF_P -> SF_P
repLocRefs lfp sfp =
    Map.map (setConcatMap $ rep Set.empty) sfp
    where rep :: Set.Set MyOccurrence -> MyOccurrence -> Set.Set MyOccurrence 
          rep done occ | occ `Set.member` done = Set.empty
                       | isLoc occ   = setConcatMap (rep $ Set.insert occ done) $ 
                                       findWithErr lfp "repping locals" occ
                       | otherwise   = Set.singleton occ

-- | Add dependencies from a higher order child to all its attributes
addHigherOrders :: SF_P -> SF_P -> SF_P
addHigherOrders lfp sfp = 
   Map.mapWithKey f $ Map.map (setConcatMap (\mo -> f mo (Set.singleton mo))) sfp
   where f :: MyOccurrence -> Set.Set MyOccurrence -> Set.Set MyOccurrence
         f mo@(MyOccurrence (p,f) _) deps =
           let ho = ((p,"inst") >.< (f,AnyDir))
           in  if ho `Map.member` lfp
               then ho `Set.insert` deps
               else deps
{-# LINE 131 "src-generated/LOAG/Order.hs" #-}

{-# LINE 42 "src-ag/LOAG/Order.ag" #-}

fst' (a,_,_) = a
snd' (_,b,_) = b
trd' (_,_,c) = c
{-# LINE 138 "src-generated/LOAG/Order.hs" #-}

{-# LINE 95 "src-ag/LOAG/Order.ag" #-}

data AltAttr = AltAttr Identifier Identifier Bool
               deriving (Eq, Ord, Show)

edgeToDep :: PMP -> Edge -> Dependency
edgeToDep pmp (f,t) = 
    Dependency (OccAttr (identifier f1) (identifier i1)) 
               (OccAttr (identifier f2) (identifier i2))
    where (MyOccurrence (_,f1) (i1,_),MyOccurrence (_,f2) (i2,_))
            = (findWithErr pmp "edgeToDep" f, 
               findWithErr pmp "edgeToDep" t) 

ppAds :: Options -> PMP -> [Edge] -> PP_Doc
ppAds opts pmp = foldr ((>-<) . ppEdge opts pmp) empty

ppEdge :: Options -> PMP -> Edge -> PP_Doc
ppEdge opts pmp (f,t) = 
    text sem    >#< text (show ty) >|< " | " >|< text p >|< "   "
                >|< ppOcc pmp f >|< text " < " >|< ppOcc pmp t
 where (MyOccurrence ((ty,p),_) _) = pmp Map.! f
       sem | lcKeywords opts = "sem"
           | otherwise       = "SEM"
   
ppOcc :: PMP -> Vertex -> PP_Doc
ppOcc pmp v = text f >|< text "." >|< fst a
 where (MyOccurrence ((t,p),f) a) = findWithErr pmp "ppOcc" v

{-# LINE 168 "src-generated/LOAG/Order.hs" #-}

{-# LINE 239 "src-ag/LOAG/Order.ag" #-}

getVss (done,intros,rules,vnrs) ps tdp synsO lfp nmpr pmp pmpr fty visMap ruleMap hoMap = do
    ref   <- newSTRef done
    introed   <- newSTRef intros
    ruleref   <- newSTRef rules 
    vnrsref   <- newSTRef vnrs
    lists <- forM synsO (visit ref introed ruleref vnrsref . (pmp Map.!))
    done  <- readSTRef ref
    intros  <- readSTRef introed
    rules  <- readSTRef ruleref
    vnrs  <- readSTRef vnrsref 
    return (concat lists, (done, intros, rules, vnrs))
 where 
    hochildren = maybe Set.empty id $ Map.lookup ps hoMap
    visit ref introed ruleref vnrsref o@(MyOccurrence (_,f) (_,d)) = do
        visited <- readSTRef ref
        if (o `Set.member` visited) 
         then return [] -- already visited
         else do        -- prevent doubles
          modifySTRef ref (Set.insert o)
          if inOutput
           then do -- has to be calculated in this sequence
                rest' <- rest
                locs' <- locs
                sem'  <- sem o
                return $ (rest' ++ locs' ++ sem')
           else if "lhs" == (snd $ argsOf o)
                 then return [] -- inherited of parent, nothing todo
                 else do   -- other input occurrence, perform visit
                    locs' <- locs
                    rest' <- rest
                    visit'<- toVisit o
                    return (rest' ++ locs' ++ visit')
     where preds  = maybe [] (IS.toList . (tdp A.!)) $ Map.lookup o pmpr
           rest   = forM preds (visit ref introed ruleref vnrsref. (pmp Map.!)) 
                        >>= (return . concat)
           free   = maybe [] (Set.toList) $ Map.lookup o lfp
           locs   = forM free (visit ref introed ruleref vnrsref)
                        >>= (return . concat)
           sem o  = do  rules <- readSTRef ruleref 
                        if r `Set.member` rules
                          then return []
                          else do   writeSTRef ruleref (r `Set.insert` rules) 
                                    return [Sem r]
            where r = maybe (error "ruleMap") id $ Map.lookup o ruleMap
           inOutput = f == "lhs" && d == Syn || f /= "lhs" && d == Inh
           toVisit o = do
             vnrs <- readSTRef vnrsref 
             if (child,visnr) `Set.member` vnrs
              then return []
              else writeSTRef vnrsref ((child,visnr) `Set.insert` vnrs) >>
                   if child `Set.member` hochildren 
                   then do intros <- readSTRef introed
                           case child `Set.member` intros of
                            True    -> return [cvisit]
                            False   -> do
                                writeSTRef introed (Set.insert child intros)
                                let occ = (ps,"inst") >.< (child, AnyDir)
                                    preds = Set.toList $ setConcatMap rep $ 
                                                        lfp Map.! occ
                                    rep :: MyOccurrence -> Set.Set MyOccurrence 
                                    rep occ | isLoc occ   = Set.insert occ $ 
                                                setConcatMap rep $ lfp Map.! occ
                                            | otherwise   = Set.singleton occ
                                rest <- forM preds 
                                            (visit ref introed ruleref vnrsref)
                                sem' <- sem occ
                                return $ (concat rest) ++
                                         sem' ++
                                         [ChildIntro (identifier child)] ++
                                         [cvisit]
                   else return [cvisit]
             where  cvisit= ChildVisit (identifier child) ntid visnr
                    child = snd $ argsOf o
                    ntid  = ((\(NT name _ _ )-> name) . fromMyTy) nt 
                    visnr = (\x-> visMap IMap.! x) (nmpr Map.! (nt <.> attr o))
                    nt    = fty Map.! (ps,child)
{-# LINE 248 "src-generated/LOAG/Order.hs" #-}

{-# LINE 356 "src-ag/LOAG/Order.ag" #-}

repToAg :: LOAGRep -> Grammar -> Ag
repToAg sem (Grammar _ _ _ _ dats _ _ _ _ _ _ _ _ _) = 
    Ag bounds_s bounds_p de (map toNt dats)
 where
    pmp  = (pmp_LOAGRep_LOAGRep  sem)
    pmpr = (pmpr_LOAGRep_LOAGRep sem)
    nmp  = (nmp_LOAGRep_LOAGRep  sem)
    nmpr = (nmpr_LOAGRep_LOAGRep sem)
    genA = gen_LOAGRep_LOAGRep sem
    fieldM  = fieldMap_LOAGRep_LOAGRep sem
    genEdge (f,t) = (gen f, gen t)
    fsInP  = map2F (fsInP_LOAGRep_LOAGRep sem)
    siblings (f, t) = ofld A.! f == ofld A.! t
    ofld = (ofld_LOAGRep_LOAGRep sem)
    sfp  = map2F' (sfp_LOAGRep_LOAGRep sem)
    afp  = filter inOutput . ap
    ap   = map (findWithErr pmpr "building ap") . map2F (ap_LOAGRep_LOAGRep  sem)
    inss = inss_LOAGRep_LOAGRep sem 
    gen v = genA A.! v
    ain  = map (findWithErr nmpr "building an") . map2F (ain_LOAGRep_LOAGRep sem)
    asn  = map (findWithErr nmpr "building an") . map2F (asn_LOAGRep_LOAGRep sem)
    inOutput = not . inContext 
    inContext f = (f1 == "lhs" && d1 == Inh || f1 /= "lhs" && d1 == Syn) 
        where (MyOccurrence (_,f1) (_,d1)) = pmp Map.! f
    de    = [ e      | p <- ps,   e <- dpe p ]
    dpe p = [ (findWithErr pmpr "building dpe" a, b) 
            | b <- ap p, a <- Set.toList $ sfp (findWithErr pmp "fetching sfp" b) ]
    ps   = ps_LOAGRep_LOAGRep   sem
    bounds_p = if Map.null pmp then (0,-1) 
                else (fst $ Map.findMin pmp, fst $ Map.findMax pmp)
    bounds_s = if Map.null nmp then (0,-1) 
                else (fst $ Map.findMin nmp, fst $ Map.findMax nmp)
 


    toNt :: Nonterminal -> Nt
    toNt (Nonterminal ntid _ _ _ prods) = Nt nt dpf dpt 
            (addD Inh $ ain ty) (addD Syn $ asn ty) (map (toPr ty) prods)
     where nt  = getName ntid
           ty  = TyData nt
           dpt =  [ (as, ai) | ai <- ain ty
                   , as <- nub$ [ gen s |
                                  i <- inss A.! ai
                                , s <- map (pmpr Map.!) $ 
                                    Set.toList (sfp $ pmp Map.! i)
                                , siblings (s,i)]]
           dpf =  [ (ai, as) | as <- asn ty
                   , ai <- nub$ [ gen i |
                                  s <- inss A.! as
                                , i <- map (pmpr Map.!) $
                                    Set.toList (sfp $ pmp Map.! s)
                                , siblings (i,s)]]
           addD d = map (\i -> (i,inss A.! i,d))
    toPr :: MyType -> Production -> Pr
    toPr ty (Production con _ _ _ _ _ _) = 
                Pr p dpp fc_occs (map toFd $ fsInP p)
     where p = (ty, getName con)
           dpp = [ (f',t)
                    | t <- afp p, f <- (Set.toList $ sfp (pmp Map.! t))
                    , let f' = pmpr Map.! f
                    , not (siblings (f',t))]
           fc_occs = foldl' match [] fss
            where fss = fsInP p
           match s fs = [ ready (inp, out) lhs | inp <- Set.toList inhs
                                           , out <- Set.toList syns] ++ s
            where ((inhs, syns), lhs)
                               | (snd fs) /= "lhs" = 
                                    (swap (fieldM Map.! fs),False)
                               | otherwise = (fieldM Map.! fs, True)
                  ready e@(f,t) b = (e', genEdge e', b)
                   where e' = (pmpr Map.! f, pmpr Map.! t)
    toFd :: (PLabel, FLabel) -> Fd
    toFd fs@((TyData ty, pr), fd) = Fd fd ty inhs syns
     where (is,ss) = fieldM Map.! fs
           inhs = map (((genA A.!) &&& id).(pmpr Map.!))$ Set.toList is
           syns = map (((genA A.!) &&& id).(pmpr Map.!))$ Set.toList ss


{-# LINE 330 "src-generated/LOAG/Order.hs" #-}
-- CGrammar ----------------------------------------------------
-- wrapper
data Inh_CGrammar  = Inh_CGrammar {  }
data Syn_CGrammar  = Syn_CGrammar { Syn_CGrammar -> CGrammar
self_Syn_CGrammar :: (CGrammar) }
{-# INLINABLE wrap_CGrammar #-}
wrap_CGrammar :: T_CGrammar  -> Inh_CGrammar  -> (Syn_CGrammar )
wrap_CGrammar :: T_CGrammar -> Inh_CGrammar -> Syn_CGrammar
wrap_CGrammar (T_CGrammar Identity T_CGrammar_s2
act) (Inh_CGrammar
Inh_CGrammar ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_CGrammar_s2
sem <- Identity T_CGrammar_s2
act
        let arg1 :: T_CGrammar_vIn1
arg1 = T_CGrammar_vIn1
T_CGrammar_vIn1 
        (T_CGrammar_vOut1 CGrammar
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_CGrammar_s2 -> T_CGrammar_v1
inv_CGrammar_s2 T_CGrammar_s2
sem T_CGrammar_vIn1
arg1)
        forall (m :: * -> *) a. Monad m => a -> m a
return (CGrammar -> Syn_CGrammar
Syn_CGrammar CGrammar
_lhsOself)
   )

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

-- semantic domain
newtype T_CGrammar  = T_CGrammar {
                                 T_CGrammar -> Identity T_CGrammar_s2
attach_T_CGrammar :: Identity (T_CGrammar_s2 )
                                 }
newtype T_CGrammar_s2  = C_CGrammar_s2 {
                                       T_CGrammar_s2 -> T_CGrammar_v1
inv_CGrammar_s2 :: (T_CGrammar_v1 )
                                       }
data T_CGrammar_s3  = C_CGrammar_s3
type T_CGrammar_v1  = (T_CGrammar_vIn1 ) -> (T_CGrammar_vOut1 )
data T_CGrammar_vIn1  = T_CGrammar_vIn1 
data T_CGrammar_vOut1  = T_CGrammar_vOut1 (CGrammar)
{-# NOINLINE sem_CGrammar_CGrammar #-}
sem_CGrammar_CGrammar :: (TypeSyns) -> (Derivings) -> (Set NontermIdent) -> T_CNonterminals  -> (PragmaMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (Map NontermIdent (Map ConstructorIdent (Set Identifier))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier,[Identifier])))) -> (Bool) -> T_CGrammar 
sem_CGrammar_CGrammar :: TypeSyns
-> Map NontermIdent (Set NontermIdent)
-> Set NontermIdent
-> T_CNonterminals
-> PragmaMap
-> ParamMap
-> ContextMap
-> QuantMap
-> PragmaMap
-> Map
     NontermIdent
     (Map
        NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
-> Bool
-> T_CGrammar
sem_CGrammar_CGrammar TypeSyns
arg_typeSyns_ Map NontermIdent (Set NontermIdent)
arg_derivings_ Set NontermIdent
arg_wrappers_ T_CNonterminals
arg_nonts_ PragmaMap
arg_pragmas_ ParamMap
arg_paramMap_ ContextMap
arg_contextMap_ QuantMap
arg_quantMap_ PragmaMap
arg_aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
arg_mergeMap_ Bool
arg_multivisit_ = Identity T_CGrammar_s2 -> T_CGrammar
T_CGrammar (forall (m :: * -> *) a. Monad m => a -> m a
return T_CGrammar_s2
st2) where
   {-# NOINLINE st2 #-}
   st2 :: T_CGrammar_s2
st2 = let
      v1 :: T_CGrammar_v1 
      v1 :: T_CGrammar_v1
v1 = \ (T_CGrammar_vIn1
T_CGrammar_vIn1 ) -> ( let
         _nontsX11 :: T_CNonterminals_s11
_nontsX11 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CNonterminals -> Identity T_CNonterminals_s11
attach_T_CNonterminals (T_CNonterminals
arg_nonts_))
         (T_CNonterminals_vOut10 CNonterminals
_nontsIself) = T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 T_CNonterminals_s11
_nontsX11 (T_CNonterminals_vIn10
T_CNonterminals_vIn10 )
         _self :: CGrammar
_self = CNonterminals
-> PragmaMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map
     NontermIdent
     (Map
        NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
-> Bool
-> ParamMap
-> PragmaMap
-> QuantMap
-> TypeSyns
-> Set NontermIdent
-> CGrammar
rule0 CNonterminals
_nontsIself PragmaMap
arg_aroundsMap_ ContextMap
arg_contextMap_ Map NontermIdent (Set NontermIdent)
arg_derivings_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
arg_mergeMap_ Bool
arg_multivisit_ ParamMap
arg_paramMap_ PragmaMap
arg_pragmas_ QuantMap
arg_quantMap_ TypeSyns
arg_typeSyns_ Set NontermIdent
arg_wrappers_
         _lhsOself :: CGrammar
         _lhsOself :: CGrammar
_lhsOself = forall a. a -> a
rule1 CGrammar
_self
         __result_ :: T_CGrammar_vOut1
__result_ = CGrammar -> T_CGrammar_vOut1
T_CGrammar_vOut1 CGrammar
_lhsOself
         in T_CGrammar_vOut1
__result_ )
     in T_CGrammar_v1 -> T_CGrammar_s2
C_CGrammar_s2 T_CGrammar_v1
v1
   {-# INLINE rule0 #-}
   rule0 :: CNonterminals
-> PragmaMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map
     NontermIdent
     (Map
        NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
-> Bool
-> ParamMap
-> PragmaMap
-> QuantMap
-> TypeSyns
-> Set NontermIdent
-> CGrammar
rule0 = \ ((CNonterminals
_nontsIself) :: CNonterminals) PragmaMap
aroundsMap_ ContextMap
contextMap_ Map NontermIdent (Set NontermIdent)
derivings_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
mergeMap_ Bool
multivisit_ ParamMap
paramMap_ PragmaMap
pragmas_ QuantMap
quantMap_ TypeSyns
typeSyns_ Set NontermIdent
wrappers_ ->
     TypeSyns
-> Map NontermIdent (Set NontermIdent)
-> Set NontermIdent
-> CNonterminals
-> PragmaMap
-> ParamMap
-> ContextMap
-> QuantMap
-> PragmaMap
-> Map
     NontermIdent
     (Map
        NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
-> Bool
-> CGrammar
CGrammar TypeSyns
typeSyns_ Map NontermIdent (Set NontermIdent)
derivings_ Set NontermIdent
wrappers_ CNonterminals
_nontsIself PragmaMap
pragmas_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ PragmaMap
aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent (Map NontermIdent (NontermIdent, [NontermIdent])))
mergeMap_ Bool
multivisit_
   {-# INLINE rule1 #-}
   rule1 :: p -> p
rule1 = \ p
_self ->
     p
_self

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

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

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

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

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

-- semantic domain
newtype T_CNonterminal  = T_CNonterminal {
                                         T_CNonterminal -> Identity T_CNonterminal_s8
attach_T_CNonterminal :: Identity (T_CNonterminal_s8 )
                                         }
newtype T_CNonterminal_s8  = C_CNonterminal_s8 {
                                               T_CNonterminal_s8 -> T_CNonterminal_v7
inv_CNonterminal_s8 :: (T_CNonterminal_v7 )
                                               }
data T_CNonterminal_s9  = C_CNonterminal_s9
type T_CNonterminal_v7  = (T_CNonterminal_vIn7 ) -> (T_CNonterminal_vOut7 )
data T_CNonterminal_vIn7  = T_CNonterminal_vIn7 
data T_CNonterminal_vOut7  = T_CNonterminal_vOut7 (CNonterminal)
{-# NOINLINE sem_CNonterminal_CNonterminal #-}
sem_CNonterminal_CNonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_CProductions  -> T_CInterface  -> T_CNonterminal 
sem_CNonterminal_CNonterminal :: NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> Map NontermIdent Type
-> T_CProductions
-> T_CInterface
-> T_CNonterminal
sem_CNonterminal_CNonterminal NontermIdent
arg_nt_ [NontermIdent]
arg_params_ Map NontermIdent Type
arg_inh_ Map NontermIdent Type
arg_syn_ T_CProductions
arg_prods_ T_CInterface
arg_inter_ = Identity T_CNonterminal_s8 -> T_CNonterminal
T_CNonterminal (forall (m :: * -> *) a. Monad m => a -> m a
return T_CNonterminal_s8
st8) where
   {-# NOINLINE st8 #-}
   st8 :: T_CNonterminal_s8
st8 = let
      v7 :: T_CNonterminal_v7 
      v7 :: T_CNonterminal_v7
v7 = \ (T_CNonterminal_vIn7
T_CNonterminal_vIn7 ) -> ( let
         _prodsX17 :: T_CProductions_s17
_prodsX17 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CProductions -> Identity T_CProductions_s17
attach_T_CProductions (T_CProductions
arg_prods_))
         _interX5 :: T_CInterface_s5
_interX5 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CInterface -> Identity T_CInterface_s5
attach_T_CInterface (T_CInterface
arg_inter_))
         (T_CProductions_vOut16 CProductions
_prodsIself) = T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 T_CProductions_s17
_prodsX17 (T_CProductions_vIn16
T_CProductions_vIn16 )
         (T_CInterface_vOut4 CInterface
_interIself) = T_CInterface_s5 -> T_CInterface_v4
inv_CInterface_s5 T_CInterface_s5
_interX5 (T_CInterface_vIn4
T_CInterface_vIn4 )
         _self :: CNonterminal
_self = CInterface
-> CProductions
-> Map NontermIdent Type
-> NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> CNonterminal
rule4 CInterface
_interIself CProductions
_prodsIself Map NontermIdent Type
arg_inh_ NontermIdent
arg_nt_ [NontermIdent]
arg_params_ Map NontermIdent Type
arg_syn_
         _lhsOself :: CNonterminal
         _lhsOself :: CNonterminal
_lhsOself = forall a. a -> a
rule5 CNonterminal
_self
         __result_ :: T_CNonterminal_vOut7
__result_ = CNonterminal -> T_CNonterminal_vOut7
T_CNonterminal_vOut7 CNonterminal
_lhsOself
         in T_CNonterminal_vOut7
__result_ )
     in T_CNonterminal_v7 -> T_CNonterminal_s8
C_CNonterminal_s8 T_CNonterminal_v7
v7
   {-# INLINE rule4 #-}
   rule4 :: CInterface
-> CProductions
-> Map NontermIdent Type
-> NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> CNonterminal
rule4 = \ ((CInterface
_interIself) :: CInterface) ((CProductions
_prodsIself) :: CProductions) Map NontermIdent Type
inh_ NontermIdent
nt_ [NontermIdent]
params_ Map NontermIdent Type
syn_ ->
     NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> Map NontermIdent Type
-> CProductions
-> CInterface
-> CNonterminal
CNonterminal NontermIdent
nt_ [NontermIdent]
params_ Map NontermIdent Type
inh_ Map NontermIdent Type
syn_ CProductions
_prodsIself CInterface
_interIself
   {-# INLINE rule5 #-}
   rule5 :: p -> p
rule5 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CNonterminals  = T_CNonterminals {
                                           T_CNonterminals -> Identity T_CNonterminals_s11
attach_T_CNonterminals :: Identity (T_CNonterminals_s11 )
                                           }
newtype T_CNonterminals_s11  = C_CNonterminals_s11 {
                                                   T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 :: (T_CNonterminals_v10 )
                                                   }
data T_CNonterminals_s12  = C_CNonterminals_s12
type T_CNonterminals_v10  = (T_CNonterminals_vIn10 ) -> (T_CNonterminals_vOut10 )
data T_CNonterminals_vIn10  = T_CNonterminals_vIn10 
data T_CNonterminals_vOut10  = T_CNonterminals_vOut10 (CNonterminals)
{-# NOINLINE sem_CNonterminals_Cons #-}
sem_CNonterminals_Cons :: T_CNonterminal  -> T_CNonterminals  -> T_CNonterminals 
sem_CNonterminals_Cons :: T_CNonterminal -> T_CNonterminals -> T_CNonterminals
sem_CNonterminals_Cons T_CNonterminal
arg_hd_ T_CNonterminals
arg_tl_ = Identity T_CNonterminals_s11 -> T_CNonterminals
T_CNonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_CNonterminals_s11
st11) where
   {-# NOINLINE st11 #-}
   st11 :: T_CNonterminals_s11
st11 = let
      v10 :: T_CNonterminals_v10 
      v10 :: T_CNonterminals_v10
v10 = \ (T_CNonterminals_vIn10
T_CNonterminals_vIn10 ) -> ( let
         _hdX8 :: T_CNonterminal_s8
_hdX8 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CNonterminal -> Identity T_CNonterminal_s8
attach_T_CNonterminal (T_CNonterminal
arg_hd_))
         _tlX11 :: T_CNonterminals_s11
_tlX11 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CNonterminals -> Identity T_CNonterminals_s11
attach_T_CNonterminals (T_CNonterminals
arg_tl_))
         (T_CNonterminal_vOut7 CNonterminal
_hdIself) = T_CNonterminal_s8 -> T_CNonterminal_v7
inv_CNonterminal_s8 T_CNonterminal_s8
_hdX8 (T_CNonterminal_vIn7
T_CNonterminal_vIn7 )
         (T_CNonterminals_vOut10 CNonterminals
_tlIself) = T_CNonterminals_s11 -> T_CNonterminals_v10
inv_CNonterminals_s11 T_CNonterminals_s11
_tlX11 (T_CNonterminals_vIn10
T_CNonterminals_vIn10 )
         _self :: CNonterminals
_self = CNonterminal -> CNonterminals -> CNonterminals
rule6 CNonterminal
_hdIself CNonterminals
_tlIself
         _lhsOself :: CNonterminals
         _lhsOself :: CNonterminals
_lhsOself = forall a. a -> a
rule7 CNonterminals
_self
         __result_ :: T_CNonterminals_vOut10
__result_ = CNonterminals -> T_CNonterminals_vOut10
T_CNonterminals_vOut10 CNonterminals
_lhsOself
         in T_CNonterminals_vOut10
__result_ )
     in T_CNonterminals_v10 -> T_CNonterminals_s11
C_CNonterminals_s11 T_CNonterminals_v10
v10
   {-# INLINE rule6 #-}
   rule6 :: CNonterminal -> CNonterminals -> CNonterminals
rule6 = \ ((CNonterminal
_hdIself) :: CNonterminal) ((CNonterminals
_tlIself) :: CNonterminals) ->
     (:) CNonterminal
_hdIself CNonterminals
_tlIself
   {-# INLINE rule7 #-}
   rule7 :: p -> p
rule7 = \ p
_self ->
     p
_self
{-# NOINLINE sem_CNonterminals_Nil #-}
sem_CNonterminals_Nil ::  T_CNonterminals 
sem_CNonterminals_Nil :: T_CNonterminals
sem_CNonterminals_Nil  = Identity T_CNonterminals_s11 -> T_CNonterminals
T_CNonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_CNonterminals_s11
st11) where
   {-# NOINLINE st11 #-}
   st11 :: T_CNonterminals_s11
st11 = let
      v10 :: T_CNonterminals_v10 
      v10 :: T_CNonterminals_v10
v10 = \ (T_CNonterminals_vIn10
T_CNonterminals_vIn10 ) -> ( let
         _self :: [a]
_self = forall {a}. () -> [a]
rule8  ()
         _lhsOself :: CNonterminals
         _lhsOself :: CNonterminals
_lhsOself = forall a. a -> a
rule9 forall a. [a]
_self
         __result_ :: T_CNonterminals_vOut10
__result_ = CNonterminals -> T_CNonterminals_vOut10
T_CNonterminals_vOut10 CNonterminals
_lhsOself
         in T_CNonterminals_vOut10
__result_ )
     in T_CNonterminals_v10 -> T_CNonterminals_s11
C_CNonterminals_s11 T_CNonterminals_v10
v10
   {-# INLINE rule8 #-}
   rule8 :: () -> [a]
rule8 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule9 #-}
   rule9 :: p -> p
rule9 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CProduction  = T_CProduction {
                                       T_CProduction -> Identity T_CProduction_s14
attach_T_CProduction :: Identity (T_CProduction_s14 )
                                       }
newtype T_CProduction_s14  = C_CProduction_s14 {
                                               T_CProduction_s14 -> T_CProduction_v13
inv_CProduction_s14 :: (T_CProduction_v13 )
                                               }
data T_CProduction_s15  = C_CProduction_s15
type T_CProduction_v13  = (T_CProduction_vIn13 ) -> (T_CProduction_vOut13 )
data T_CProduction_vIn13  = T_CProduction_vIn13 
data T_CProduction_vOut13  = T_CProduction_vOut13 (CProduction)
{-# NOINLINE sem_CProduction_CProduction #-}
sem_CProduction_CProduction :: (ConstructorIdent) -> T_CVisits  -> ([(Identifier,Type,ChildKind)]) -> ([Identifier]) -> T_CProduction 
sem_CProduction_CProduction :: NontermIdent
-> T_CVisits
-> [(NontermIdent, Type, ChildKind)]
-> [NontermIdent]
-> T_CProduction
sem_CProduction_CProduction NontermIdent
arg_con_ T_CVisits
arg_visits_ [(NontermIdent, Type, ChildKind)]
arg_children_ [NontermIdent]
arg_terminals_ = Identity T_CProduction_s14 -> T_CProduction
T_CProduction (forall (m :: * -> *) a. Monad m => a -> m a
return T_CProduction_s14
st14) where
   {-# NOINLINE st14 #-}
   st14 :: T_CProduction_s14
st14 = let
      v13 :: T_CProduction_v13 
      v13 :: T_CProduction_v13
v13 = \ (T_CProduction_vIn13
T_CProduction_vIn13 ) -> ( let
         _visitsX32 :: T_CVisits_s32
_visitsX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CVisits -> Identity T_CVisits_s32
attach_T_CVisits (T_CVisits
arg_visits_))
         (T_CVisits_vOut31 CVisits
_visitsIself) = T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 T_CVisits_s32
_visitsX32 (T_CVisits_vIn31
T_CVisits_vIn31 )
         _self :: CProduction
_self = CVisits
-> [(NontermIdent, Type, ChildKind)]
-> NontermIdent
-> [NontermIdent]
-> CProduction
rule10 CVisits
_visitsIself [(NontermIdent, Type, ChildKind)]
arg_children_ NontermIdent
arg_con_ [NontermIdent]
arg_terminals_
         _lhsOself :: CProduction
         _lhsOself :: CProduction
_lhsOself = forall a. a -> a
rule11 CProduction
_self
         __result_ :: T_CProduction_vOut13
__result_ = CProduction -> T_CProduction_vOut13
T_CProduction_vOut13 CProduction
_lhsOself
         in T_CProduction_vOut13
__result_ )
     in T_CProduction_v13 -> T_CProduction_s14
C_CProduction_s14 T_CProduction_v13
v13
   {-# INLINE rule10 #-}
   rule10 :: CVisits
-> [(NontermIdent, Type, ChildKind)]
-> NontermIdent
-> [NontermIdent]
-> CProduction
rule10 = \ ((CVisits
_visitsIself) :: CVisits) [(NontermIdent, Type, ChildKind)]
children_ NontermIdent
con_ [NontermIdent]
terminals_ ->
     NontermIdent
-> CVisits
-> [(NontermIdent, Type, ChildKind)]
-> [NontermIdent]
-> CProduction
CProduction NontermIdent
con_ CVisits
_visitsIself [(NontermIdent, Type, ChildKind)]
children_ [NontermIdent]
terminals_
   {-# INLINE rule11 #-}
   rule11 :: p -> p
rule11 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CProductions  = T_CProductions {
                                         T_CProductions -> Identity T_CProductions_s17
attach_T_CProductions :: Identity (T_CProductions_s17 )
                                         }
newtype T_CProductions_s17  = C_CProductions_s17 {
                                                 T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 :: (T_CProductions_v16 )
                                                 }
data T_CProductions_s18  = C_CProductions_s18
type T_CProductions_v16  = (T_CProductions_vIn16 ) -> (T_CProductions_vOut16 )
data T_CProductions_vIn16  = T_CProductions_vIn16 
data T_CProductions_vOut16  = T_CProductions_vOut16 (CProductions)
{-# NOINLINE sem_CProductions_Cons #-}
sem_CProductions_Cons :: T_CProduction  -> T_CProductions  -> T_CProductions 
sem_CProductions_Cons :: T_CProduction -> T_CProductions -> T_CProductions
sem_CProductions_Cons T_CProduction
arg_hd_ T_CProductions
arg_tl_ = Identity T_CProductions_s17 -> T_CProductions
T_CProductions (forall (m :: * -> *) a. Monad m => a -> m a
return T_CProductions_s17
st17) where
   {-# NOINLINE st17 #-}
   st17 :: T_CProductions_s17
st17 = let
      v16 :: T_CProductions_v16 
      v16 :: T_CProductions_v16
v16 = \ (T_CProductions_vIn16
T_CProductions_vIn16 ) -> ( let
         _hdX14 :: T_CProduction_s14
_hdX14 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CProduction -> Identity T_CProduction_s14
attach_T_CProduction (T_CProduction
arg_hd_))
         _tlX17 :: T_CProductions_s17
_tlX17 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CProductions -> Identity T_CProductions_s17
attach_T_CProductions (T_CProductions
arg_tl_))
         (T_CProduction_vOut13 CProduction
_hdIself) = T_CProduction_s14 -> T_CProduction_v13
inv_CProduction_s14 T_CProduction_s14
_hdX14 (T_CProduction_vIn13
T_CProduction_vIn13 )
         (T_CProductions_vOut16 CProductions
_tlIself) = T_CProductions_s17 -> T_CProductions_v16
inv_CProductions_s17 T_CProductions_s17
_tlX17 (T_CProductions_vIn16
T_CProductions_vIn16 )
         _self :: CProductions
_self = CProduction -> CProductions -> CProductions
rule12 CProduction
_hdIself CProductions
_tlIself
         _lhsOself :: CProductions
         _lhsOself :: CProductions
_lhsOself = forall a. a -> a
rule13 CProductions
_self
         __result_ :: T_CProductions_vOut16
__result_ = CProductions -> T_CProductions_vOut16
T_CProductions_vOut16 CProductions
_lhsOself
         in T_CProductions_vOut16
__result_ )
     in T_CProductions_v16 -> T_CProductions_s17
C_CProductions_s17 T_CProductions_v16
v16
   {-# INLINE rule12 #-}
   rule12 :: CProduction -> CProductions -> CProductions
rule12 = \ ((CProduction
_hdIself) :: CProduction) ((CProductions
_tlIself) :: CProductions) ->
     (:) CProduction
_hdIself CProductions
_tlIself
   {-# INLINE rule13 #-}
   rule13 :: p -> p
rule13 = \ p
_self ->
     p
_self
{-# NOINLINE sem_CProductions_Nil #-}
sem_CProductions_Nil ::  T_CProductions 
sem_CProductions_Nil :: T_CProductions
sem_CProductions_Nil  = Identity T_CProductions_s17 -> T_CProductions
T_CProductions (forall (m :: * -> *) a. Monad m => a -> m a
return T_CProductions_s17
st17) where
   {-# NOINLINE st17 #-}
   st17 :: T_CProductions_s17
st17 = let
      v16 :: T_CProductions_v16 
      v16 :: T_CProductions_v16
v16 = \ (T_CProductions_vIn16
T_CProductions_vIn16 ) -> ( let
         _self :: [a]
_self = forall {a}. () -> [a]
rule14  ()
         _lhsOself :: CProductions
         _lhsOself :: CProductions
_lhsOself = forall a. a -> a
rule15 forall a. [a]
_self
         __result_ :: T_CProductions_vOut16
__result_ = CProductions -> T_CProductions_vOut16
T_CProductions_vOut16 CProductions
_lhsOself
         in T_CProductions_vOut16
__result_ )
     in T_CProductions_v16 -> T_CProductions_s17
C_CProductions_s17 T_CProductions_v16
v16
   {-# INLINE rule14 #-}
   rule14 :: () -> [a]
rule14 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule15 #-}
   rule15 :: p -> p
rule15 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CRule  = T_CRule {
                           T_CRule -> Identity T_CRule_s20
attach_T_CRule :: Identity (T_CRule_s20 )
                           }
newtype T_CRule_s20  = C_CRule_s20 {
                                   T_CRule_s20 -> T_CRule_v19
inv_CRule_s20 :: (T_CRule_v19 )
                                   }
data T_CRule_s21  = C_CRule_s21
type T_CRule_v19  = (T_CRule_vIn19 ) -> (T_CRule_vOut19 )
data T_CRule_vIn19  = T_CRule_vIn19 
data T_CRule_vOut19  = T_CRule_vOut19 (CRule)
{-# NOINLINE sem_CRule_CRule #-}
sem_CRule_CRule :: (Identifier) -> (Bool) -> (Bool) -> (NontermIdent) -> (ConstructorIdent) -> (Identifier) -> (Maybe NontermIdent) -> (Maybe Type) -> T_Pattern  -> ([String]) -> (Map Int (Identifier,Identifier,Maybe Type)) -> (Bool) -> (String) -> (Set (Identifier, Identifier)) -> (Bool) -> (Maybe Identifier) -> T_CRule 
sem_CRule_CRule :: NontermIdent
-> Bool
-> Bool
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Maybe NontermIdent
-> Maybe Type
-> T_Pattern
-> [FLabel]
-> Map Int (NontermIdent, NontermIdent, Maybe Type)
-> Bool
-> FLabel
-> Set (NontermIdent, NontermIdent)
-> Bool
-> Maybe NontermIdent
-> T_CRule
sem_CRule_CRule NontermIdent
arg_name_ Bool
arg_isIn_ Bool
arg_hasCode_ NontermIdent
arg_nt_ NontermIdent
arg_con_ NontermIdent
arg_field_ Maybe NontermIdent
arg_childnt_ Maybe Type
arg_tp_ T_Pattern
arg_pattern_ [FLabel]
arg_rhs_ Map Int (NontermIdent, NontermIdent, Maybe Type)
arg_defines_ Bool
arg_owrt_ FLabel
arg_origin_ Set (NontermIdent, NontermIdent)
arg_uses_ Bool
arg_explicit_ Maybe NontermIdent
arg_mbNamed_ = Identity T_CRule_s20 -> T_CRule
T_CRule (forall (m :: * -> *) a. Monad m => a -> m a
return T_CRule_s20
st20) where
   {-# NOINLINE st20 #-}
   st20 :: T_CRule_s20
st20 = let
      v19 :: T_CRule_v19 
      v19 :: T_CRule_v19
v19 = \ (T_CRule_vIn19
T_CRule_vIn19 ) -> ( let
         _patternX77 :: T_Pattern_s77
_patternX77 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s77
attach_T_Pattern (T_Pattern
arg_pattern_))
         (T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_patternIafs Pattern
_patternIcopy Pattern
_patternIself) = T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 T_Pattern_s77
_patternX77 (T_Pattern_vIn76
T_Pattern_vIn76 )
         _self :: CRule
_self = Pattern
-> Maybe NontermIdent
-> NontermIdent
-> Map Int (NontermIdent, NontermIdent, Maybe Type)
-> Bool
-> NontermIdent
-> Bool
-> Bool
-> Maybe NontermIdent
-> NontermIdent
-> NontermIdent
-> FLabel
-> Bool
-> [FLabel]
-> Maybe Type
-> Set (NontermIdent, NontermIdent)
-> CRule
rule16 Pattern
_patternIself Maybe NontermIdent
arg_childnt_ NontermIdent
arg_con_ Map Int (NontermIdent, NontermIdent, Maybe Type)
arg_defines_ Bool
arg_explicit_ NontermIdent
arg_field_ Bool
arg_hasCode_ Bool
arg_isIn_ Maybe NontermIdent
arg_mbNamed_ NontermIdent
arg_name_ NontermIdent
arg_nt_ FLabel
arg_origin_ Bool
arg_owrt_ [FLabel]
arg_rhs_ Maybe Type
arg_tp_ Set (NontermIdent, NontermIdent)
arg_uses_
         _lhsOself :: CRule
         _lhsOself :: CRule
_lhsOself = forall a. a -> a
rule17 CRule
_self
         __result_ :: T_CRule_vOut19
__result_ = CRule -> T_CRule_vOut19
T_CRule_vOut19 CRule
_lhsOself
         in T_CRule_vOut19
__result_ )
     in T_CRule_v19 -> T_CRule_s20
C_CRule_s20 T_CRule_v19
v19
   {-# INLINE rule16 #-}
   rule16 :: Pattern
-> Maybe NontermIdent
-> NontermIdent
-> Map Int (NontermIdent, NontermIdent, Maybe Type)
-> Bool
-> NontermIdent
-> Bool
-> Bool
-> Maybe NontermIdent
-> NontermIdent
-> NontermIdent
-> FLabel
-> Bool
-> [FLabel]
-> Maybe Type
-> Set (NontermIdent, NontermIdent)
-> CRule
rule16 = \ ((Pattern
_patternIself) :: Pattern) Maybe NontermIdent
childnt_ NontermIdent
con_ Map Int (NontermIdent, NontermIdent, Maybe Type)
defines_ Bool
explicit_ NontermIdent
field_ Bool
hasCode_ Bool
isIn_ Maybe NontermIdent
mbNamed_ NontermIdent
name_ NontermIdent
nt_ FLabel
origin_ Bool
owrt_ [FLabel]
rhs_ Maybe Type
tp_ Set (NontermIdent, NontermIdent)
uses_ ->
     NontermIdent
-> Bool
-> Bool
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Maybe NontermIdent
-> Maybe Type
-> Pattern
-> [FLabel]
-> Map Int (NontermIdent, NontermIdent, Maybe Type)
-> Bool
-> FLabel
-> Set (NontermIdent, NontermIdent)
-> Bool
-> Maybe NontermIdent
-> CRule
CRule NontermIdent
name_ Bool
isIn_ Bool
hasCode_ NontermIdent
nt_ NontermIdent
con_ NontermIdent
field_ Maybe NontermIdent
childnt_ Maybe Type
tp_ Pattern
_patternIself [FLabel]
rhs_ Map Int (NontermIdent, NontermIdent, Maybe Type)
defines_ Bool
owrt_ FLabel
origin_ Set (NontermIdent, NontermIdent)
uses_ Bool
explicit_ Maybe NontermIdent
mbNamed_
   {-# INLINE rule17 #-}
   rule17 :: p -> p
rule17 = \ p
_self ->
     p
_self
{-# NOINLINE sem_CRule_CChildVisit #-}
sem_CRule_CChildVisit :: (Identifier) -> (NontermIdent) -> (Int) -> (Attributes) -> (Attributes) -> (Bool) -> T_CRule 
sem_CRule_CChildVisit :: NontermIdent
-> NontermIdent
-> Int
-> Map NontermIdent Type
-> Map NontermIdent Type
-> Bool
-> T_CRule
sem_CRule_CChildVisit NontermIdent
arg_name_ NontermIdent
arg_nt_ Int
arg_nr_ Map NontermIdent Type
arg_inh_ Map NontermIdent Type
arg_syn_ Bool
arg_isLast_ = Identity T_CRule_s20 -> T_CRule
T_CRule (forall (m :: * -> *) a. Monad m => a -> m a
return T_CRule_s20
st20) where
   {-# NOINLINE st20 #-}
   st20 :: T_CRule_s20
st20 = let
      v19 :: T_CRule_v19 
      v19 :: T_CRule_v19
v19 = \ (T_CRule_vIn19
T_CRule_vIn19 ) -> ( let
         _self :: CRule
_self = Map NontermIdent Type
-> Bool
-> NontermIdent
-> Int
-> NontermIdent
-> Map NontermIdent Type
-> CRule
rule18 Map NontermIdent Type
arg_inh_ Bool
arg_isLast_ NontermIdent
arg_name_ Int
arg_nr_ NontermIdent
arg_nt_ Map NontermIdent Type
arg_syn_
         _lhsOself :: CRule
         _lhsOself :: CRule
_lhsOself = forall a. a -> a
rule19 CRule
_self
         __result_ :: T_CRule_vOut19
__result_ = CRule -> T_CRule_vOut19
T_CRule_vOut19 CRule
_lhsOself
         in T_CRule_vOut19
__result_ )
     in T_CRule_v19 -> T_CRule_s20
C_CRule_s20 T_CRule_v19
v19
   {-# INLINE rule18 #-}
   rule18 :: Map NontermIdent Type
-> Bool
-> NontermIdent
-> Int
-> NontermIdent
-> Map NontermIdent Type
-> CRule
rule18 = \ Map NontermIdent Type
inh_ Bool
isLast_ NontermIdent
name_ Int
nr_ NontermIdent
nt_ Map NontermIdent Type
syn_ ->
     NontermIdent
-> NontermIdent
-> Int
-> Map NontermIdent Type
-> Map NontermIdent Type
-> Bool
-> CRule
CChildVisit NontermIdent
name_ NontermIdent
nt_ Int
nr_ Map NontermIdent Type
inh_ Map NontermIdent Type
syn_ Bool
isLast_
   {-# INLINE rule19 #-}
   rule19 :: p -> p
rule19 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CSegment  = T_CSegment {
                                 T_CSegment -> Identity T_CSegment_s23
attach_T_CSegment :: Identity (T_CSegment_s23 )
                                 }
newtype T_CSegment_s23  = C_CSegment_s23 {
                                         T_CSegment_s23 -> T_CSegment_v22
inv_CSegment_s23 :: (T_CSegment_v22 )
                                         }
data T_CSegment_s24  = C_CSegment_s24
type T_CSegment_v22  = (T_CSegment_vIn22 ) -> (T_CSegment_vOut22 )
data T_CSegment_vIn22  = T_CSegment_vIn22 
data T_CSegment_vOut22  = T_CSegment_vOut22 (CSegment)
{-# NOINLINE sem_CSegment_CSegment #-}
sem_CSegment_CSegment :: (Attributes) -> (Attributes) -> T_CSegment 
sem_CSegment_CSegment :: Map NontermIdent Type -> Map NontermIdent Type -> T_CSegment
sem_CSegment_CSegment Map NontermIdent Type
arg_inh_ Map NontermIdent Type
arg_syn_ = Identity T_CSegment_s23 -> T_CSegment
T_CSegment (forall (m :: * -> *) a. Monad m => a -> m a
return T_CSegment_s23
st23) where
   {-# NOINLINE st23 #-}
   st23 :: T_CSegment_s23
st23 = let
      v22 :: T_CSegment_v22 
      v22 :: T_CSegment_v22
v22 = \ (T_CSegment_vIn22
T_CSegment_vIn22 ) -> ( let
         _self :: CSegment
_self = Map NontermIdent Type -> Map NontermIdent Type -> CSegment
rule20 Map NontermIdent Type
arg_inh_ Map NontermIdent Type
arg_syn_
         _lhsOself :: CSegment
         _lhsOself :: CSegment
_lhsOself = forall a. a -> a
rule21 CSegment
_self
         __result_ :: T_CSegment_vOut22
__result_ = CSegment -> T_CSegment_vOut22
T_CSegment_vOut22 CSegment
_lhsOself
         in T_CSegment_vOut22
__result_ )
     in T_CSegment_v22 -> T_CSegment_s23
C_CSegment_s23 T_CSegment_v22
v22
   {-# INLINE rule20 #-}
   rule20 :: Map NontermIdent Type -> Map NontermIdent Type -> CSegment
rule20 = \ Map NontermIdent Type
inh_ Map NontermIdent Type
syn_ ->
     Map NontermIdent Type -> Map NontermIdent Type -> CSegment
CSegment Map NontermIdent Type
inh_ Map NontermIdent Type
syn_
   {-# INLINE rule21 #-}
   rule21 :: p -> p
rule21 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CSegments  = T_CSegments {
                                   T_CSegments -> Identity T_CSegments_s26
attach_T_CSegments :: Identity (T_CSegments_s26 )
                                   }
newtype T_CSegments_s26  = C_CSegments_s26 {
                                           T_CSegments_s26 -> T_CSegments_v25
inv_CSegments_s26 :: (T_CSegments_v25 )
                                           }
data T_CSegments_s27  = C_CSegments_s27
type T_CSegments_v25  = (T_CSegments_vIn25 ) -> (T_CSegments_vOut25 )
data T_CSegments_vIn25  = T_CSegments_vIn25 
data T_CSegments_vOut25  = T_CSegments_vOut25 (CSegments)
{-# NOINLINE sem_CSegments_Cons #-}
sem_CSegments_Cons :: T_CSegment  -> T_CSegments  -> T_CSegments 
sem_CSegments_Cons :: T_CSegment -> T_CSegments -> T_CSegments
sem_CSegments_Cons T_CSegment
arg_hd_ T_CSegments
arg_tl_ = Identity T_CSegments_s26 -> T_CSegments
T_CSegments (forall (m :: * -> *) a. Monad m => a -> m a
return T_CSegments_s26
st26) where
   {-# NOINLINE st26 #-}
   st26 :: T_CSegments_s26
st26 = let
      v25 :: T_CSegments_v25 
      v25 :: T_CSegments_v25
v25 = \ (T_CSegments_vIn25
T_CSegments_vIn25 ) -> ( let
         _hdX23 :: T_CSegment_s23
_hdX23 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CSegment -> Identity T_CSegment_s23
attach_T_CSegment (T_CSegment
arg_hd_))
         _tlX26 :: T_CSegments_s26
_tlX26 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CSegments -> Identity T_CSegments_s26
attach_T_CSegments (T_CSegments
arg_tl_))
         (T_CSegment_vOut22 CSegment
_hdIself) = T_CSegment_s23 -> T_CSegment_v22
inv_CSegment_s23 T_CSegment_s23
_hdX23 (T_CSegment_vIn22
T_CSegment_vIn22 )
         (T_CSegments_vOut25 [CSegment]
_tlIself) = T_CSegments_s26 -> T_CSegments_v25
inv_CSegments_s26 T_CSegments_s26
_tlX26 (T_CSegments_vIn25
T_CSegments_vIn25 )
         _self :: [CSegment]
_self = CSegment -> [CSegment] -> [CSegment]
rule22 CSegment
_hdIself [CSegment]
_tlIself
         _lhsOself :: CSegments
         _lhsOself :: [CSegment]
_lhsOself = forall a. a -> a
rule23 [CSegment]
_self
         __result_ :: T_CSegments_vOut25
__result_ = [CSegment] -> T_CSegments_vOut25
T_CSegments_vOut25 [CSegment]
_lhsOself
         in T_CSegments_vOut25
__result_ )
     in T_CSegments_v25 -> T_CSegments_s26
C_CSegments_s26 T_CSegments_v25
v25
   {-# INLINE rule22 #-}
   rule22 :: CSegment -> [CSegment] -> [CSegment]
rule22 = \ ((CSegment
_hdIself) :: CSegment) (([CSegment]
_tlIself) :: CSegments) ->
     (:) CSegment
_hdIself [CSegment]
_tlIself
   {-# INLINE rule23 #-}
   rule23 :: p -> p
rule23 = \ p
_self ->
     p
_self
{-# NOINLINE sem_CSegments_Nil #-}
sem_CSegments_Nil ::  T_CSegments 
sem_CSegments_Nil :: T_CSegments
sem_CSegments_Nil  = Identity T_CSegments_s26 -> T_CSegments
T_CSegments (forall (m :: * -> *) a. Monad m => a -> m a
return T_CSegments_s26
st26) where
   {-# NOINLINE st26 #-}
   st26 :: T_CSegments_s26
st26 = let
      v25 :: T_CSegments_v25 
      v25 :: T_CSegments_v25
v25 = \ (T_CSegments_vIn25
T_CSegments_vIn25 ) -> ( let
         _self :: [a]
_self = forall {a}. () -> [a]
rule24  ()
         _lhsOself :: CSegments
         _lhsOself :: [CSegment]
_lhsOself = forall a. a -> a
rule25 forall a. [a]
_self
         __result_ :: T_CSegments_vOut25
__result_ = [CSegment] -> T_CSegments_vOut25
T_CSegments_vOut25 [CSegment]
_lhsOself
         in T_CSegments_vOut25
__result_ )
     in T_CSegments_v25 -> T_CSegments_s26
C_CSegments_s26 T_CSegments_v25
v25
   {-# INLINE rule24 #-}
   rule24 :: () -> [a]
rule24 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule25 #-}
   rule25 :: p -> p
rule25 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CVisit  = T_CVisit {
                             T_CVisit -> Identity T_CVisit_s29
attach_T_CVisit :: Identity (T_CVisit_s29 )
                             }
newtype T_CVisit_s29  = C_CVisit_s29 {
                                     T_CVisit_s29 -> T_CVisit_v28
inv_CVisit_s29 :: (T_CVisit_v28 )
                                     }
data T_CVisit_s30  = C_CVisit_s30
type T_CVisit_v28  = (T_CVisit_vIn28 ) -> (T_CVisit_vOut28 )
data T_CVisit_vIn28  = T_CVisit_vIn28 
data T_CVisit_vOut28  = T_CVisit_vOut28 (CVisit)
{-# NOINLINE sem_CVisit_CVisit #-}
sem_CVisit_CVisit :: (Attributes) -> (Attributes) -> T_Sequence  -> T_Sequence  -> (Bool) -> T_CVisit 
sem_CVisit_CVisit :: Map NontermIdent Type
-> Map NontermIdent Type
-> T_Sequence
-> T_Sequence
-> Bool
-> T_CVisit
sem_CVisit_CVisit Map NontermIdent Type
arg_inh_ Map NontermIdent Type
arg_syn_ T_Sequence
arg_vss_ T_Sequence
arg_intra_ Bool
arg_ordered_ = Identity T_CVisit_s29 -> T_CVisit
T_CVisit (forall (m :: * -> *) a. Monad m => a -> m a
return T_CVisit_s29
st29) where
   {-# NOINLINE st29 #-}
   st29 :: T_CVisit_s29
st29 = let
      v28 :: T_CVisit_v28 
      v28 :: T_CVisit_v28
v28 = \ (T_CVisit_vIn28
T_CVisit_vIn28 ) -> ( let
         _vssX95 :: T_Sequence_s95
_vssX95 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Sequence -> Identity T_Sequence_s95
attach_T_Sequence (T_Sequence
arg_vss_))
         _intraX95 :: T_Sequence_s95
_intraX95 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Sequence -> Identity T_Sequence_s95
attach_T_Sequence (T_Sequence
arg_intra_))
         (T_Sequence_vOut94 Sequence
_vssIself) = T_Sequence_s95 -> T_Sequence_v94
inv_Sequence_s95 T_Sequence_s95
_vssX95 (T_Sequence_vIn94
T_Sequence_vIn94 )
         (T_Sequence_vOut94 Sequence
_intraIself) = T_Sequence_s95 -> T_Sequence_v94
inv_Sequence_s95 T_Sequence_s95
_intraX95 (T_Sequence_vIn94
T_Sequence_vIn94 )
         _self :: CVisit
_self = Sequence
-> Sequence
-> Map NontermIdent Type
-> Bool
-> Map NontermIdent Type
-> CVisit
rule26 Sequence
_intraIself Sequence
_vssIself Map NontermIdent Type
arg_inh_ Bool
arg_ordered_ Map NontermIdent Type
arg_syn_
         _lhsOself :: CVisit
         _lhsOself :: CVisit
_lhsOself = forall a. a -> a
rule27 CVisit
_self
         __result_ :: T_CVisit_vOut28
__result_ = CVisit -> T_CVisit_vOut28
T_CVisit_vOut28 CVisit
_lhsOself
         in T_CVisit_vOut28
__result_ )
     in T_CVisit_v28 -> T_CVisit_s29
C_CVisit_s29 T_CVisit_v28
v28
   {-# INLINE rule26 #-}
   rule26 :: Sequence
-> Sequence
-> Map NontermIdent Type
-> Bool
-> Map NontermIdent Type
-> CVisit
rule26 = \ ((Sequence
_intraIself) :: Sequence) ((Sequence
_vssIself) :: Sequence) Map NontermIdent Type
inh_ Bool
ordered_ Map NontermIdent Type
syn_ ->
     Map NontermIdent Type
-> Map NontermIdent Type -> Sequence -> Sequence -> Bool -> CVisit
CVisit Map NontermIdent Type
inh_ Map NontermIdent Type
syn_ Sequence
_vssIself Sequence
_intraIself Bool
ordered_
   {-# INLINE rule27 #-}
   rule27 :: p -> p
rule27 = \ p
_self ->
     p
_self

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

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

-- semantic domain
newtype T_CVisits  = T_CVisits {
                               T_CVisits -> Identity T_CVisits_s32
attach_T_CVisits :: Identity (T_CVisits_s32 )
                               }
newtype T_CVisits_s32  = C_CVisits_s32 {
                                       T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 :: (T_CVisits_v31 )
                                       }
data T_CVisits_s33  = C_CVisits_s33
type T_CVisits_v31  = (T_CVisits_vIn31 ) -> (T_CVisits_vOut31 )
data T_CVisits_vIn31  = T_CVisits_vIn31 
data T_CVisits_vOut31  = T_CVisits_vOut31 (CVisits)
{-# NOINLINE sem_CVisits_Cons #-}
sem_CVisits_Cons :: T_CVisit  -> T_CVisits  -> T_CVisits 
sem_CVisits_Cons :: T_CVisit -> T_CVisits -> T_CVisits
sem_CVisits_Cons T_CVisit
arg_hd_ T_CVisits
arg_tl_ = Identity T_CVisits_s32 -> T_CVisits
T_CVisits (forall (m :: * -> *) a. Monad m => a -> m a
return T_CVisits_s32
st32) where
   {-# NOINLINE st32 #-}
   st32 :: T_CVisits_s32
st32 = let
      v31 :: T_CVisits_v31 
      v31 :: T_CVisits_v31
v31 = \ (T_CVisits_vIn31
T_CVisits_vIn31 ) -> ( let
         _hdX29 :: T_CVisit_s29
_hdX29 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CVisit -> Identity T_CVisit_s29
attach_T_CVisit (T_CVisit
arg_hd_))
         _tlX32 :: T_CVisits_s32
_tlX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CVisits -> Identity T_CVisits_s32
attach_T_CVisits (T_CVisits
arg_tl_))
         (T_CVisit_vOut28 CVisit
_hdIself) = T_CVisit_s29 -> T_CVisit_v28
inv_CVisit_s29 T_CVisit_s29
_hdX29 (T_CVisit_vIn28
T_CVisit_vIn28 )
         (T_CVisits_vOut31 CVisits
_tlIself) = T_CVisits_s32 -> T_CVisits_v31
inv_CVisits_s32 T_CVisits_s32
_tlX32 (T_CVisits_vIn31
T_CVisits_vIn31 )
         _self :: CVisits
_self = CVisit -> CVisits -> CVisits
rule28 CVisit
_hdIself CVisits
_tlIself
         _lhsOself :: CVisits
         _lhsOself :: CVisits
_lhsOself = forall a. a -> a
rule29 CVisits
_self
         __result_ :: T_CVisits_vOut31
__result_ = CVisits -> T_CVisits_vOut31
T_CVisits_vOut31 CVisits
_lhsOself
         in T_CVisits_vOut31
__result_ )
     in T_CVisits_v31 -> T_CVisits_s32
C_CVisits_s32 T_CVisits_v31
v31
   {-# INLINE rule28 #-}
   rule28 :: CVisit -> CVisits -> CVisits
rule28 = \ ((CVisit
_hdIself) :: CVisit) ((CVisits
_tlIself) :: CVisits) ->
     (:) CVisit
_hdIself CVisits
_tlIself
   {-# INLINE rule29 #-}
   rule29 :: p -> p
rule29 = \ p
_self ->
     p
_self
{-# NOINLINE sem_CVisits_Nil #-}
sem_CVisits_Nil ::  T_CVisits 
sem_CVisits_Nil :: T_CVisits
sem_CVisits_Nil  = Identity T_CVisits_s32 -> T_CVisits
T_CVisits (forall (m :: * -> *) a. Monad m => a -> m a
return T_CVisits_s32
st32) where
   {-# NOINLINE st32 #-}
   st32 :: T_CVisits_s32
st32 = let
      v31 :: T_CVisits_v31 
      v31 :: T_CVisits_v31
v31 = \ (T_CVisits_vIn31
T_CVisits_vIn31 ) -> ( let
         _self :: [a]
_self = forall {a}. () -> [a]
rule30  ()
         _lhsOself :: CVisits
         _lhsOself :: CVisits
_lhsOself = forall a. a -> a
rule31 forall a. [a]
_self
         __result_ :: T_CVisits_vOut31
__result_ = CVisits -> T_CVisits_vOut31
T_CVisits_vOut31 CVisits
_lhsOself
         in T_CVisits_vOut31
__result_ )
     in T_CVisits_v31 -> T_CVisits_s32
C_CVisits_s32 T_CVisits_v31
v31
   {-# INLINE rule30 #-}
   rule30 :: () -> [a]
rule30 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule31 #-}
   rule31 :: p -> p
rule31 = \ p
_self ->
     p
_self

-- Child -------------------------------------------------------
-- wrapper
data Inh_Child  = Inh_Child { Inh_Child -> MyType -> MyAttributes
ain_Inh_Child :: (MyType -> MyAttributes), Inh_Child -> MyType -> MyAttributes
an_Inh_Child :: (MyType -> MyAttributes), Inh_Child -> Map NontermIdent [Expression]
aroundMap_Inh_Child :: (Map Identifier [Expression]), Inh_Child -> MyType -> MyAttributes
asn_Inh_Child :: (MyType -> MyAttributes), Inh_Child -> Int
flab_Inh_Child :: (Int), Inh_Child -> FTY
fty_Inh_Child :: (FTY), Inh_Child -> HOMap
hoMapf_Inh_Child :: (HOMap), Inh_Child -> SF_P
lfpf_Inh_Child :: (SF_P), Inh_Child
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
mergeMap_Inh_Child :: (Map Identifier (Identifier, [Identifier], Expression)), Inh_Child -> Set NontermIdent
mergedChildren_Inh_Child :: (Set Identifier), Inh_Child -> NMP
nmp_Inh_Child :: (NMP), Inh_Child -> NMP_R
nmprf_Inh_Child :: (NMP_R), Inh_Child -> Int
olab_Inh_Child :: (Int), Inh_Child -> Options
options_Inh_Child :: (Options), Inh_Child -> PLabel
pll_Inh_Child :: (PLabel), Inh_Child -> PMP
pmpf_Inh_Child :: (PMP), Inh_Child -> PMP_R
pmprf_Inh_Child :: (PMP_R) }
data Syn_Child  = Syn_Child { Syn_Child -> A_P
ap_Syn_Child :: (A_P), Syn_Child -> EChild
echilds_Syn_Child :: (EChild), Syn_Child -> FMap
fieldMap_Syn_Child :: (FMap), Syn_Child -> Int
flab_Syn_Child :: (Int), Syn_Child -> FTY
fty_Syn_Child :: (FTY), Syn_Child -> Map Int Int
gen_Syn_Child :: (Map Int Int), Syn_Child -> HOMap
hoMap_Syn_Child :: (HOMap), Syn_Child -> Map Int [Int]
inss_Syn_Child :: (Map Int [Int]), Syn_Child -> [Edge]
ofld_Syn_Child :: ([(Int, Int)]), Syn_Child -> Int
olab_Syn_Child :: (Int), Syn_Child -> PMP
pmp_Syn_Child :: (PMP), Syn_Child -> PMP_R
pmpr_Syn_Child :: (PMP_R), Syn_Child -> Set FLabel
pts_Syn_Child :: (Set.Set FLabel), Syn_Child -> Set NontermIdent
refHoNts_Syn_Child :: (Set NontermIdent), Syn_Child -> Set NontermIdent
refNts_Syn_Child :: (Set NontermIdent), Syn_Child -> Child
self_Syn_Child :: (Child) }
{-# INLINABLE wrap_Child #-}
wrap_Child :: T_Child  -> Inh_Child  -> (Syn_Child )
wrap_Child :: T_Child -> Inh_Child -> Syn_Child
wrap_Child (T_Child Identity T_Child_s35
act) (Inh_Child MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Child_s35
sem <- Identity T_Child_s35
act
        let arg34 :: T_Child_vIn34
arg34 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent [Expression]
-> (MyType -> MyAttributes)
-> Int
-> FTY
-> HOMap
-> SF_P
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Set NontermIdent
-> NMP
-> NMP_R
-> Int
-> Options
-> PLabel
-> PMP
-> PMP_R
-> T_Child_vIn34
T_Child_vIn34 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf
        (T_Child_vOut34 A_P
_lhsOap EChild
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Child
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Child_s35 -> T_Child_v34
inv_Child_s35 T_Child_s35
sem T_Child_vIn34
arg34)
        forall (m :: * -> *) a. Monad m => a -> m a
return (A_P
-> EChild
-> FMap
-> Int
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> Set FLabel
-> Set NontermIdent
-> Set NontermIdent
-> Child
-> Syn_Child
Syn_Child A_P
_lhsOap EChild
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Child
_lhsOself)
   )

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

-- semantic domain
newtype T_Child  = T_Child {
                           T_Child -> Identity T_Child_s35
attach_T_Child :: Identity (T_Child_s35 )
                           }
newtype T_Child_s35  = C_Child_s35 {
                                   T_Child_s35 -> T_Child_v34
inv_Child_s35 :: (T_Child_v34 )
                                   }
data T_Child_s36  = C_Child_s36
type T_Child_v34  = (T_Child_vIn34 ) -> (T_Child_vOut34 )
data T_Child_vIn34  = T_Child_vIn34 (MyType -> MyAttributes) (MyType -> MyAttributes) (Map Identifier [Expression]) (MyType -> MyAttributes) (Int) (FTY) (HOMap) (SF_P) (Map Identifier (Identifier, [Identifier], Expression)) (Set Identifier) (NMP) (NMP_R) (Int) (Options) (PLabel) (PMP) (PMP_R)
data T_Child_vOut34  = T_Child_vOut34 (A_P) (EChild) (FMap) (Int) (FTY) (Map Int Int) (HOMap) (Map Int [Int]) ([(Int, Int)]) (Int) (PMP) (PMP_R) (Set.Set FLabel) (Set NontermIdent) (Set NontermIdent) (Child)
{-# NOINLINE sem_Child_Child #-}
sem_Child_Child :: (Identifier) -> (Type) -> (ChildKind) ->  T_Child 
sem_Child_Child :: NontermIdent -> Type -> ChildKind -> T_Child
sem_Child_Child NontermIdent
arg_name_ Type
arg_tp_ ChildKind
arg_kind_  = Identity T_Child_s35 -> T_Child
T_Child (forall (m :: * -> *) a. Monad m => a -> m a
return T_Child_s35
st35) where
   {-# NOINLINE st35 #-}
   st35 :: T_Child_s35
st35 = let
      v34 :: T_Child_v34 
      v34 :: T_Child_v34
v34 = \ (T_Child_vIn34 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf) -> ( let
         _fattsX47 :: T_FieldAtts_s47
_fattsX47 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_FieldAtts -> Identity T_FieldAtts_s47
attach_T_FieldAtts (([FieldAtt] -> T_FieldAtts
sem_FieldAtts [FieldAtt]
fatts_val_)))
         (T_FieldAtts_vOut46 A_P
_fattsIap Int
_fattsIflab FTY
_fattsIfty Map Int Int
_fattsIgen Map Int [Int]
_fattsIinss [Edge]
_fattsIofld Int
_fattsIolab PMP
_fattsIpmp PMP_R
_fattsIpmpr [FieldAtt]
_fattsIself) = T_FieldAtts_s47 -> T_FieldAtts_v46
inv_FieldAtts_s47 T_FieldAtts_s47
_fattsX47 ((MyType -> MyAttributes)
-> Int -> NMP_R -> Int -> T_FieldAtts_vIn46
T_FieldAtts_vIn46 MyType -> MyAttributes
_fattsOan Int
_fattsOflab NMP_R
_fattsOnmprf Int
_fattsOolab)
         _refNts :: Set NontermIdent
_refNts = Type -> Set NontermIdent
rule32 Type
arg_tp_
         _refHoNts :: Set NontermIdent
_refHoNts = Bool -> Set NontermIdent -> Set NontermIdent
rule33 Bool
_isHigherOrder Set NontermIdent
_refNts
         _isHigherOrder :: Bool
_isHigherOrder = ChildKind -> Bool
rule34 ChildKind
arg_kind_
         _hasArounds :: Bool
_hasArounds = Map NontermIdent [Expression] -> NontermIdent -> Bool
rule35 Map NontermIdent [Expression]
_lhsIaroundMap NontermIdent
arg_name_
         _merges :: Maybe [NontermIdent]
_merges = Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> NontermIdent -> Maybe [NontermIdent]
rule36 Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap NontermIdent
arg_name_
         _isMerged :: Bool
_isMerged = Set NontermIdent -> NontermIdent -> Bool
rule37 Set NontermIdent
_lhsImergedChildren NontermIdent
arg_name_
         _lhsOechilds :: EChild
         _lhsOechilds :: EChild
_lhsOechilds = Bool
-> Bool
-> Maybe [NontermIdent]
-> ChildKind
-> NontermIdent
-> Type
-> EChild
rule38 Bool
_hasArounds Bool
_isMerged Maybe [NontermIdent]
_merges ChildKind
arg_kind_ NontermIdent
arg_name_ Type
arg_tp_
         _flab :: Int
_flab = Int -> Int
rule39 Int
_lhsIflab
         _atp :: MyType
_atp = Type -> MyType
rule40 Type
arg_tp_
         fatts_val_ :: [FieldAtt]
fatts_val_ = MyType
-> (MyType -> MyAttributes) -> PLabel -> NontermIdent -> [FieldAtt]
rule41 MyType
_atp MyType -> MyAttributes
_lhsIan PLabel
_lhsIpll NontermIdent
arg_name_
         _fattsOflab :: Int
_fattsOflab = forall a. a -> a
rule42 Int
_flab
         _ident :: FLabel
_ident = NontermIdent -> FLabel
rule43 NontermIdent
arg_name_
         _label :: (PLabel, FLabel)
_label = forall {b}. b -> PLabel -> (PLabel, b)
rule44 FLabel
_ident PLabel
_lhsIpll
         _foccsI :: Set MyOccurrence
_foccsI = MyType
-> (PLabel, FLabel) -> (MyType -> MyAttributes) -> Set MyOccurrence
rule45 MyType
_atp (PLabel, FLabel)
_label MyType -> MyAttributes
_lhsIain
         _foccsS :: Set MyOccurrence
_foccsS = MyType
-> (PLabel, FLabel) -> (MyType -> MyAttributes) -> Set MyOccurrence
rule46 MyType
_atp (PLabel, FLabel)
_label MyType -> MyAttributes
_lhsIasn
         _fieldMap :: FMap
_fieldMap = forall {a} {a} {k}. Set a -> Set a -> k -> Map k (Set a, Set a)
rule47 Set MyOccurrence
_foccsI Set MyOccurrence
_foccsS (PLabel, FLabel)
_label
         _hoMap :: HOMap
_hoMap = forall {a}. a -> PLabel -> ChildKind -> Map PLabel (Set a)
rule48 FLabel
_ident PLabel
_lhsIpll ChildKind
arg_kind_
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = forall {a}. a -> PLabel -> NontermIdent -> Map (PLabel, FLabel) a
rule49 MyType
_atp PLabel
_lhsIpll NontermIdent
arg_name_
         _lhsOpts :: Set.Set FLabel
         _lhsOpts :: Set FLabel
_lhsOpts = NontermIdent -> Set FLabel
rule50 NontermIdent
arg_name_
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P
rule51 A_P
_fattsIap
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = forall a. a -> a
rule52 FMap
_fieldMap
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int
rule53 Map Int Int
_fattsIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = forall a. a -> a
rule54 HOMap
_hoMap
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int]
rule55 Map Int [Int]
_fattsIinss
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge]
rule56 [Edge]
_fattsIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP
rule57 PMP
_fattsIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R
rule58 PMP_R
_fattsIpmpr
         _lhsOrefHoNts :: Set NontermIdent
         _lhsOrefHoNts :: Set NontermIdent
_lhsOrefHoNts = forall a. a -> a
rule59 Set NontermIdent
_refHoNts
         _lhsOrefNts :: Set NontermIdent
         _lhsOrefNts :: Set NontermIdent
_lhsOrefNts = forall a. a -> a
rule60 Set NontermIdent
_refNts
         _self :: Child
_self = ChildKind -> NontermIdent -> Type -> Child
rule61 ChildKind
arg_kind_ NontermIdent
arg_name_ Type
arg_tp_
         _lhsOself :: Child
         _lhsOself :: Child
_lhsOself = forall a. a -> a
rule62 Child
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = forall a. a -> a
rule63 Int
_flab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule64 Int
_fattsIolab
         _fattsOan :: MyType -> MyAttributes
_fattsOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule65 MyType -> MyAttributes
_lhsIan
         _fattsOnmprf :: NMP_R
_fattsOnmprf = NMP_R -> NMP_R
rule66 NMP_R
_lhsInmprf
         _fattsOolab :: Int
_fattsOolab = Int -> Int
rule67 Int
_lhsIolab
         __result_ :: T_Child_vOut34
__result_ = A_P
-> EChild
-> FMap
-> Int
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> Set FLabel
-> Set NontermIdent
-> Set NontermIdent
-> Child
-> T_Child_vOut34
T_Child_vOut34 A_P
_lhsOap EChild
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Child
_lhsOself
         in T_Child_vOut34
__result_ )
     in T_Child_v34 -> T_Child_s35
C_Child_s35 T_Child_v34
v34
   {-# INLINE rule32 #-}
   {-# LINE 31 "src-ag/ExecutionPlanCommon.ag" #-}
   rule32 = \ tp_ ->
                 {-# LINE 31 "src-ag/ExecutionPlanCommon.ag" #-}
                 case tp_ of
                   NT nt _ _ -> Set.singleton nt
                   _         -> mempty
                 {-# LINE 1110 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule33 #-}
   {-# LINE 34 "src-ag/ExecutionPlanCommon.ag" #-}
   rule33 = \ _isHigherOrder _refNts ->
                   {-# LINE 34 "src-ag/ExecutionPlanCommon.ag" #-}
                   if _isHigherOrder     then _refNts     else mempty
                   {-# LINE 1116 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule34 #-}
   {-# LINE 35 "src-ag/ExecutionPlanCommon.ag" #-}
   rule34 = \ kind_ ->
                        {-# LINE 35 "src-ag/ExecutionPlanCommon.ag" #-}
                        case kind_ of
                          ChildSyntax -> False
                          _           -> True
                        {-# LINE 1124 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule35 #-}
   {-# LINE 95 "src-ag/ExecutionPlanCommon.ag" #-}
   rule35 = \ ((_lhsIaroundMap) :: Map Identifier [Expression]) name_ ->
                     {-# LINE 95 "src-ag/ExecutionPlanCommon.ag" #-}
                     case Map.lookup name_ _lhsIaroundMap of
                       Nothing -> False
                       Just as -> not (null as)
                     {-# LINE 1132 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule36 #-}
   {-# LINE 123 "src-ag/ExecutionPlanCommon.ag" #-}
   rule36 = \ ((_lhsImergeMap) :: Map Identifier (Identifier, [Identifier], Expression)) name_ ->
                   {-# LINE 123 "src-ag/ExecutionPlanCommon.ag" #-}
                   maybe Nothing (\(_,ms,_) -> Just ms) $ Map.lookup name_ _lhsImergeMap
                   {-# LINE 1138 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule37 #-}
   {-# LINE 124 "src-ag/ExecutionPlanCommon.ag" #-}
   rule37 = \ ((_lhsImergedChildren) :: Set Identifier) name_ ->
                   {-# LINE 124 "src-ag/ExecutionPlanCommon.ag" #-}
                   name_ `Set.member` _lhsImergedChildren
                   {-# LINE 1144 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule38 #-}
   {-# LINE 135 "src-ag/ExecutionPlanCommon.ag" #-}
   rule38 = \ _hasArounds _isMerged _merges kind_ name_ tp_ ->
                          {-# LINE 135 "src-ag/ExecutionPlanCommon.ag" #-}
                          case tp_ of
                            NT _ _ _ -> EChild name_ tp_ kind_ _hasArounds     _merges     _isMerged
                            _        -> ETerm name_ tp_
                          {-# LINE 1152 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule39 #-}
   {-# LINE 174 "src-ag/LOAG/Prepare.ag" #-}
   rule39 = \ ((_lhsIflab) :: Int) ->
                    {-# LINE 174 "src-ag/LOAG/Prepare.ag" #-}
                    _lhsIflab + 1
                    {-# LINE 1158 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule40 #-}
   {-# LINE 175 "src-ag/LOAG/Prepare.ag" #-}
   rule40 = \ tp_ ->
                    {-# LINE 175 "src-ag/LOAG/Prepare.ag" #-}
                    toMyTy tp_
                    {-# LINE 1164 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule41 #-}
   {-# LINE 177 "src-ag/LOAG/Prepare.ag" #-}
   rule41 = \ _atp ((_lhsIan) :: MyType -> MyAttributes) ((_lhsIpll) :: PLabel) name_ ->
                    {-# LINE 177 "src-ag/LOAG/Prepare.ag" #-}
                    map ((FieldAtt _atp     _lhsIpll (getName name_)) . alab)
                          $ _lhsIan _atp
                    {-# LINE 1171 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule42 #-}
   {-# LINE 179 "src-ag/LOAG/Prepare.ag" #-}
   rule42 = \ _flab ->
                    {-# LINE 179 "src-ag/LOAG/Prepare.ag" #-}
                    _flab
                    {-# LINE 1177 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule43 #-}
   {-# LINE 180 "src-ag/LOAG/Prepare.ag" #-}
   rule43 = \ name_ ->
                    {-# LINE 180 "src-ag/LOAG/Prepare.ag" #-}
                    getName name_
                    {-# LINE 1183 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule44 #-}
   {-# LINE 181 "src-ag/LOAG/Prepare.ag" #-}
   rule44 = \ _ident ((_lhsIpll) :: PLabel) ->
                    {-# LINE 181 "src-ag/LOAG/Prepare.ag" #-}
                    (_lhsIpll, _ident    )
                    {-# LINE 1189 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule45 #-}
   {-# LINE 182 "src-ag/LOAG/Prepare.ag" #-}
   rule45 = \ _atp _label ((_lhsIain) :: MyType -> MyAttributes) ->
                    {-# LINE 182 "src-ag/LOAG/Prepare.ag" #-}
                    Set.fromList $ handAllOut _label     $ _lhsIain _atp
                    {-# LINE 1195 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule46 #-}
   {-# LINE 183 "src-ag/LOAG/Prepare.ag" #-}
   rule46 = \ _atp _label ((_lhsIasn) :: MyType -> MyAttributes) ->
                    {-# LINE 183 "src-ag/LOAG/Prepare.ag" #-}
                    Set.fromList $ handAllOut _label     $ _lhsIasn _atp
                    {-# LINE 1201 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule47 #-}
   {-# LINE 184 "src-ag/LOAG/Prepare.ag" #-}
   rule47 = \ _foccsI _foccsS _label ->
                    {-# LINE 184 "src-ag/LOAG/Prepare.ag" #-}
                    if Set.null _foccsI     && Set.null _foccsS
                          then Map.empty
                          else Map.singleton _label     (_foccsS    ,_foccsI    )
                    {-# LINE 1209 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule48 #-}
   {-# LINE 187 "src-ag/LOAG/Prepare.ag" #-}
   rule48 = \ _ident ((_lhsIpll) :: PLabel) kind_ ->
                    {-# LINE 187 "src-ag/LOAG/Prepare.ag" #-}
                    case kind_ of
                      ChildAttr -> Map.singleton _lhsIpll (Set.singleton _ident    )
                      _         -> Map.empty
                    {-# LINE 1217 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule49 #-}
   {-# LINE 190 "src-ag/LOAG/Prepare.ag" #-}
   rule49 = \ _atp ((_lhsIpll) :: PLabel) name_ ->
                    {-# LINE 190 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton (_lhsIpll, getName name_) _atp
                    {-# LINE 1223 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule50 #-}
   {-# LINE 223 "src-ag/LOAG/Prepare.ag" #-}
   rule50 = \ name_ ->
                {-# LINE 223 "src-ag/LOAG/Prepare.ag" #-}
                Set.singleton $ getName name_
                {-# LINE 1229 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule51 #-}
   rule51 = \ ((_fattsIap) :: A_P) ->
     _fattsIap
   {-# INLINE rule52 #-}
   rule52 = \ _fieldMap ->
     _fieldMap
   {-# INLINE rule53 #-}
   rule53 = \ ((_fattsIgen) :: Map Int Int) ->
     _fattsIgen
   {-# INLINE rule54 #-}
   rule54 = \ _hoMap ->
     _hoMap
   {-# INLINE rule55 #-}
   rule55 = \ ((_fattsIinss) :: Map Int [Int]) ->
     _fattsIinss
   {-# INLINE rule56 #-}
   rule56 = \ ((_fattsIofld) :: [(Int, Int)]) ->
     _fattsIofld
   {-# INLINE rule57 #-}
   rule57 = \ ((_fattsIpmp) :: PMP) ->
     _fattsIpmp
   {-# INLINE rule58 #-}
   rule58 = \ ((_fattsIpmpr) :: PMP_R) ->
     _fattsIpmpr
   {-# INLINE rule59 #-}
   rule59 = \ _refHoNts ->
     _refHoNts
   {-# INLINE rule60 #-}
   rule60 = \ _refNts ->
     _refNts
   {-# INLINE rule61 #-}
   rule61 = \ kind_ name_ tp_ ->
     Child name_ tp_ kind_
   {-# INLINE rule62 #-}
   rule62 = \ _self ->
     _self
   {-# INLINE rule63 #-}
   rule63 = \ _flab ->
     _flab
   {-# INLINE rule64 #-}
   rule64 = \ ((_fattsIolab) :: Int) ->
     _fattsIolab
   {-# INLINE rule65 #-}
   rule65 = \ ((_lhsIan) :: MyType -> MyAttributes) ->
     _lhsIan
   {-# INLINE rule66 #-}
   rule66 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule67 #-}
   rule67 = \ ((_lhsIolab) :: Int) ->
     _lhsIolab

-- Children ----------------------------------------------------
-- wrapper
data Inh_Children  = Inh_Children { Inh_Children -> MyType -> MyAttributes
ain_Inh_Children :: (MyType -> MyAttributes), Inh_Children -> MyType -> MyAttributes
an_Inh_Children :: (MyType -> MyAttributes), Inh_Children -> Map NontermIdent [Expression]
aroundMap_Inh_Children :: (Map Identifier [Expression]), Inh_Children -> MyType -> MyAttributes
asn_Inh_Children :: (MyType -> MyAttributes), Inh_Children -> MyType
dty_Inh_Children :: (MyType), Inh_Children -> Int
flab_Inh_Children :: (Int), Inh_Children -> FTY
fty_Inh_Children :: (FTY), Inh_Children -> HOMap
hoMapf_Inh_Children :: (HOMap), Inh_Children -> SF_P
lfpf_Inh_Children :: (SF_P), Inh_Children
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
mergeMap_Inh_Children :: (Map Identifier (Identifier, [Identifier], Expression)), Inh_Children -> Set NontermIdent
mergedChildren_Inh_Children :: (Set Identifier), Inh_Children -> NMP
nmp_Inh_Children :: (NMP), Inh_Children -> NMP_R
nmprf_Inh_Children :: (NMP_R), Inh_Children -> Int
olab_Inh_Children :: (Int), Inh_Children -> Options
options_Inh_Children :: (Options), Inh_Children -> PLabel
pll_Inh_Children :: (PLabel), Inh_Children -> PMP
pmpf_Inh_Children :: (PMP), Inh_Children -> PMP_R
pmprf_Inh_Children :: (PMP_R) }
data Syn_Children  = Syn_Children { Syn_Children -> A_P
ap_Syn_Children :: (A_P), Syn_Children -> EChildren
echilds_Syn_Children :: (EChildren), Syn_Children -> FMap
fieldMap_Syn_Children :: (FMap), Syn_Children -> Int
flab_Syn_Children :: (Int), Syn_Children -> FTY
fty_Syn_Children :: (FTY), Syn_Children -> Map Int Int
gen_Syn_Children :: (Map Int Int), Syn_Children -> HOMap
hoMap_Syn_Children :: (HOMap), Syn_Children -> Map Int [Int]
inss_Syn_Children :: (Map Int [Int]), Syn_Children -> [Edge]
ofld_Syn_Children :: ([(Int, Int)]), Syn_Children -> Int
olab_Syn_Children :: (Int), Syn_Children -> PMP
pmp_Syn_Children :: (PMP), Syn_Children -> PMP_R
pmpr_Syn_Children :: (PMP_R), Syn_Children -> Set FLabel
pts_Syn_Children :: (Set.Set FLabel), Syn_Children -> Set NontermIdent
refHoNts_Syn_Children :: (Set NontermIdent), Syn_Children -> Set NontermIdent
refNts_Syn_Children :: (Set NontermIdent), Syn_Children -> Children
self_Syn_Children :: (Children) }
{-# INLINABLE wrap_Children #-}
wrap_Children :: T_Children  -> Inh_Children  -> (Syn_Children )
wrap_Children :: T_Children -> Inh_Children -> Syn_Children
wrap_Children (T_Children Identity T_Children_s38
act) (Inh_Children MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Children_s38
sem <- Identity T_Children_s38
act
        let arg37 :: T_Children_vIn37
arg37 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent [Expression]
-> (MyType -> MyAttributes)
-> MyType
-> Int
-> FTY
-> HOMap
-> SF_P
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Set NontermIdent
-> NMP
-> NMP_R
-> Int
-> Options
-> PLabel
-> PMP
-> PMP_R
-> T_Children_vIn37
T_Children_vIn37 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf
        (T_Children_vOut37 A_P
_lhsOap EChildren
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Children
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Children_s38 -> T_Children_v37
inv_Children_s38 T_Children_s38
sem T_Children_vIn37
arg37)
        forall (m :: * -> *) a. Monad m => a -> m a
return (A_P
-> EChildren
-> FMap
-> Int
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> Set FLabel
-> Set NontermIdent
-> Set NontermIdent
-> Children
-> Syn_Children
Syn_Children A_P
_lhsOap EChildren
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Children
_lhsOself)
   )

-- cata
{-# NOINLINE sem_Children #-}
sem_Children :: Children  -> T_Children 
sem_Children :: Children -> T_Children
sem_Children Children
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Child -> T_Children -> T_Children
sem_Children_Cons T_Children
sem_Children_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Child -> T_Child
sem_Child Children
list)

-- semantic domain
newtype T_Children  = T_Children {
                                 T_Children -> Identity T_Children_s38
attach_T_Children :: Identity (T_Children_s38 )
                                 }
newtype T_Children_s38  = C_Children_s38 {
                                         T_Children_s38 -> T_Children_v37
inv_Children_s38 :: (T_Children_v37 )
                                         }
data T_Children_s39  = C_Children_s39
type T_Children_v37  = (T_Children_vIn37 ) -> (T_Children_vOut37 )
data T_Children_vIn37  = T_Children_vIn37 (MyType -> MyAttributes) (MyType -> MyAttributes) (Map Identifier [Expression]) (MyType -> MyAttributes) (MyType) (Int) (FTY) (HOMap) (SF_P) (Map Identifier (Identifier, [Identifier], Expression)) (Set Identifier) (NMP) (NMP_R) (Int) (Options) (PLabel) (PMP) (PMP_R)
data T_Children_vOut37  = T_Children_vOut37 (A_P) (EChildren) (FMap) (Int) (FTY) (Map Int Int) (HOMap) (Map Int [Int]) ([(Int, Int)]) (Int) (PMP) (PMP_R) (Set.Set FLabel) (Set NontermIdent) (Set NontermIdent) (Children)
{-# NOINLINE sem_Children_Cons #-}
sem_Children_Cons :: T_Child  -> T_Children  -> T_Children 
sem_Children_Cons :: T_Child -> T_Children -> T_Children
sem_Children_Cons T_Child
arg_hd_ T_Children
arg_tl_ = Identity T_Children_s38 -> T_Children
T_Children (forall (m :: * -> *) a. Monad m => a -> m a
return T_Children_s38
st38) where
   {-# NOINLINE st38 #-}
   st38 :: T_Children_s38
st38 = let
      v37 :: T_Children_v37 
      v37 :: T_Children_v37
v37 = \ (T_Children_vIn37 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf) -> ( let
         _hdX35 :: T_Child_s35
_hdX35 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Child -> Identity T_Child_s35
attach_T_Child (T_Child
arg_hd_))
         _tlX38 :: T_Children_s38
_tlX38 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s38
attach_T_Children (T_Children
arg_tl_))
         (T_Child_vOut34 A_P
_hdIap EChild
_hdIechilds FMap
_hdIfieldMap Int
_hdIflab FTY
_hdIfty Map Int Int
_hdIgen HOMap
_hdIhoMap Map Int [Int]
_hdIinss [Edge]
_hdIofld Int
_hdIolab PMP
_hdIpmp PMP_R
_hdIpmpr Set FLabel
_hdIpts Set NontermIdent
_hdIrefHoNts Set NontermIdent
_hdIrefNts Child
_hdIself) = T_Child_s35 -> T_Child_v34
inv_Child_s35 T_Child_s35
_hdX35 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent [Expression]
-> (MyType -> MyAttributes)
-> Int
-> FTY
-> HOMap
-> SF_P
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Set NontermIdent
-> NMP
-> NMP_R
-> Int
-> Options
-> PLabel
-> PMP
-> PMP_R
-> T_Child_vIn34
T_Child_vIn34 MyType -> MyAttributes
_hdOain MyType -> MyAttributes
_hdOan Map NontermIdent [Expression]
_hdOaroundMap MyType -> MyAttributes
_hdOasn Int
_hdOflab FTY
_hdOfty HOMap
_hdOhoMapf SF_P
_hdOlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_hdOmergeMap Set NontermIdent
_hdOmergedChildren NMP
_hdOnmp NMP_R
_hdOnmprf Int
_hdOolab Options
_hdOoptions PLabel
_hdOpll PMP
_hdOpmpf PMP_R
_hdOpmprf)
         (T_Children_vOut37 A_P
_tlIap EChildren
_tlIechilds FMap
_tlIfieldMap Int
_tlIflab FTY
_tlIfty Map Int Int
_tlIgen HOMap
_tlIhoMap Map Int [Int]
_tlIinss [Edge]
_tlIofld Int
_tlIolab PMP
_tlIpmp PMP_R
_tlIpmpr Set FLabel
_tlIpts Set NontermIdent
_tlIrefHoNts Set NontermIdent
_tlIrefNts Children
_tlIself) = T_Children_s38 -> T_Children_v37
inv_Children_s38 T_Children_s38
_tlX38 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent [Expression]
-> (MyType -> MyAttributes)
-> MyType
-> Int
-> FTY
-> HOMap
-> SF_P
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Set NontermIdent
-> NMP
-> NMP_R
-> Int
-> Options
-> PLabel
-> PMP
-> PMP_R
-> T_Children_vIn37
T_Children_vIn37 MyType -> MyAttributes
_tlOain MyType -> MyAttributes
_tlOan Map NontermIdent [Expression]
_tlOaroundMap MyType -> MyAttributes
_tlOasn MyType
_tlOdty Int
_tlOflab FTY
_tlOfty HOMap
_tlOhoMapf SF_P
_tlOlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_tlOmergeMap Set NontermIdent
_tlOmergedChildren NMP
_tlOnmp NMP_R
_tlOnmprf Int
_tlOolab Options
_tlOoptions PLabel
_tlOpll PMP
_tlOpmpf PMP_R
_tlOpmprf)
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P -> A_P
rule68 A_P
_hdIap A_P
_tlIap
         _lhsOechilds :: EChildren
         _lhsOechilds :: EChildren
_lhsOechilds = EChild -> EChildren -> EChildren
rule69 EChild
_hdIechilds EChildren
_tlIechilds
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = FMap -> FMap -> FMap
rule70 FMap
_hdIfieldMap FMap
_tlIfieldMap
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = FTY -> FTY -> FTY
rule71 FTY
_hdIfty FTY
_tlIfty
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int -> Map Int Int
rule72 Map Int Int
_hdIgen Map Int Int
_tlIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = HOMap -> HOMap -> HOMap
rule73 HOMap
_hdIhoMap HOMap
_tlIhoMap
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule74 Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge] -> [Edge]
rule75 [Edge]
_hdIofld [Edge]
_tlIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP -> PMP
rule76 PMP
_hdIpmp PMP
_tlIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R -> PMP_R
rule77 PMP_R
_hdIpmpr PMP_R
_tlIpmpr
         _lhsOpts :: Set.Set FLabel
         _lhsOpts :: Set FLabel
_lhsOpts = Set FLabel -> Set FLabel -> Set FLabel
rule78 Set FLabel
_hdIpts Set FLabel
_tlIpts
         _lhsOrefHoNts :: Set NontermIdent
         _lhsOrefHoNts :: Set NontermIdent
_lhsOrefHoNts = Set NontermIdent -> Set NontermIdent -> Set NontermIdent
rule79 Set NontermIdent
_hdIrefHoNts Set NontermIdent
_tlIrefHoNts
         _lhsOrefNts :: Set NontermIdent
         _lhsOrefNts :: Set NontermIdent
_lhsOrefNts = Set NontermIdent -> Set NontermIdent -> Set NontermIdent
rule80 Set NontermIdent
_hdIrefNts Set NontermIdent
_tlIrefNts
         _self :: Children
_self = Child -> Children -> Children
rule81 Child
_hdIself Children
_tlIself
         _lhsOself :: Children
         _lhsOself :: Children
_lhsOself = forall a. a -> a
rule82 Children
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule83 Int
_tlIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule84 Int
_tlIolab
         _hdOain :: MyType -> MyAttributes
_hdOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule85 MyType -> MyAttributes
_lhsIain
         _hdOan :: MyType -> MyAttributes
_hdOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule86 MyType -> MyAttributes
_lhsIan
         _hdOaroundMap :: Map NontermIdent [Expression]
_hdOaroundMap = Map NontermIdent [Expression] -> Map NontermIdent [Expression]
rule87 Map NontermIdent [Expression]
_lhsIaroundMap
         _hdOasn :: MyType -> MyAttributes
_hdOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule88 MyType -> MyAttributes
_lhsIasn
         _hdOflab :: Int
_hdOflab = Int -> Int
rule89 Int
_lhsIflab
         _hdOfty :: FTY
_hdOfty = FTY -> FTY
rule90 FTY
_lhsIfty
         _hdOhoMapf :: HOMap
_hdOhoMapf = HOMap -> HOMap
rule91 HOMap
_lhsIhoMapf
         _hdOlfpf :: SF_P
_hdOlfpf = SF_P -> SF_P
rule92 SF_P
_lhsIlfpf
         _hdOmergeMap :: Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_hdOmergeMap = Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
rule93 Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap
         _hdOmergedChildren :: Set NontermIdent
_hdOmergedChildren = Set NontermIdent -> Set NontermIdent
rule94 Set NontermIdent
_lhsImergedChildren
         _hdOnmp :: NMP
_hdOnmp = NMP -> NMP
rule95 NMP
_lhsInmp
         _hdOnmprf :: NMP_R
_hdOnmprf = NMP_R -> NMP_R
rule96 NMP_R
_lhsInmprf
         _hdOolab :: Int
_hdOolab = Int -> Int
rule97 Int
_lhsIolab
         _hdOoptions :: Options
_hdOoptions = Options -> Options
rule98 Options
_lhsIoptions
         _hdOpll :: PLabel
_hdOpll = PLabel -> PLabel
rule99 PLabel
_lhsIpll
         _hdOpmpf :: PMP
_hdOpmpf = PMP -> PMP
rule100 PMP
_lhsIpmpf
         _hdOpmprf :: PMP_R
_hdOpmprf = PMP_R -> PMP_R
rule101 PMP_R
_lhsIpmprf
         _tlOain :: MyType -> MyAttributes
_tlOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule102 MyType -> MyAttributes
_lhsIain
         _tlOan :: MyType -> MyAttributes
_tlOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule103 MyType -> MyAttributes
_lhsIan
         _tlOaroundMap :: Map NontermIdent [Expression]
_tlOaroundMap = Map NontermIdent [Expression] -> Map NontermIdent [Expression]
rule104 Map NontermIdent [Expression]
_lhsIaroundMap
         _tlOasn :: MyType -> MyAttributes
_tlOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule105 MyType -> MyAttributes
_lhsIasn
         _tlOdty :: MyType
_tlOdty = MyType -> MyType
rule106 MyType
_lhsIdty
         _tlOflab :: Int
_tlOflab = Int -> Int
rule107 Int
_hdIflab
         _tlOfty :: FTY
_tlOfty = FTY -> FTY
rule108 FTY
_hdIfty
         _tlOhoMapf :: HOMap
_tlOhoMapf = HOMap -> HOMap
rule109 HOMap
_lhsIhoMapf
         _tlOlfpf :: SF_P
_tlOlfpf = SF_P -> SF_P
rule110 SF_P
_lhsIlfpf
         _tlOmergeMap :: Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_tlOmergeMap = Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
rule111 Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap
         _tlOmergedChildren :: Set NontermIdent
_tlOmergedChildren = Set NontermIdent -> Set NontermIdent
rule112 Set NontermIdent
_lhsImergedChildren
         _tlOnmp :: NMP
_tlOnmp = NMP -> NMP
rule113 NMP
_lhsInmp
         _tlOnmprf :: NMP_R
_tlOnmprf = NMP_R -> NMP_R
rule114 NMP_R
_lhsInmprf
         _tlOolab :: Int
_tlOolab = Int -> Int
rule115 Int
_hdIolab
         _tlOoptions :: Options
_tlOoptions = Options -> Options
rule116 Options
_lhsIoptions
         _tlOpll :: PLabel
_tlOpll = PLabel -> PLabel
rule117 PLabel
_lhsIpll
         _tlOpmpf :: PMP
_tlOpmpf = PMP -> PMP
rule118 PMP
_lhsIpmpf
         _tlOpmprf :: PMP_R
_tlOpmprf = PMP_R -> PMP_R
rule119 PMP_R
_lhsIpmprf
         __result_ :: T_Children_vOut37
__result_ = A_P
-> EChildren
-> FMap
-> Int
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> Set FLabel
-> Set NontermIdent
-> Set NontermIdent
-> Children
-> T_Children_vOut37
T_Children_vOut37 A_P
_lhsOap EChildren
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Children
_lhsOself
         in T_Children_vOut37
__result_ )
     in T_Children_v37 -> T_Children_s38
C_Children_s38 T_Children_v37
v37
   {-# INLINE rule68 #-}
   rule68 :: A_P -> A_P -> A_P
rule68 = \ ((A_P
_hdIap) :: A_P) ((A_P
_tlIap) :: A_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith forall a. [a] -> [a] -> [a]
(++) A_P
_hdIap A_P
_tlIap)
   {-# INLINE rule69 #-}
   rule69 :: EChild -> EChildren -> EChildren
rule69 = \ ((EChild
_hdIechilds) :: EChild) ((EChildren
_tlIechilds) :: EChildren) ->
     EChild
_hdIechilds forall a. a -> [a] -> [a]
: EChildren
_tlIechilds
   {-# INLINE rule70 #-}
   rule70 :: FMap -> FMap -> FMap
rule70 = \ ((FMap
_hdIfieldMap) :: FMap) ((FMap
_tlIfieldMap) :: FMap) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union FMap
_hdIfieldMap FMap
_tlIfieldMap)
   {-# INLINE rule71 #-}
   rule71 :: FTY -> FTY -> FTY
rule71 = \ ((FTY
_hdIfty) :: FTY) ((FTY
_tlIfty) :: FTY) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union FTY
_hdIfty FTY
_tlIfty)
   {-# INLINE rule72 #-}
   rule72 :: Map Int Int -> Map Int Int -> Map Int Int
rule72 = \ ((Map Int Int
_hdIgen) :: Map Int Int) ((Map Int Int
_tlIgen) :: Map Int Int) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map Int Int
_hdIgen Map Int Int
_tlIgen)
   {-# INLINE rule73 #-}
   rule73 :: HOMap -> HOMap -> HOMap
rule73 = \ ((HOMap
_hdIhoMap) :: HOMap) ((HOMap
_tlIhoMap) :: HOMap) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) HOMap
_hdIhoMap HOMap
_tlIhoMap)
   {-# INLINE rule74 #-}
   rule74 :: Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule74 = \ ((Map Int [Int]
_hdIinss) :: Map Int [Int]) ((Map Int [Int]
_tlIinss) :: Map Int [Int]) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith forall a. [a] -> [a] -> [a]
(++) Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss)
   {-# INLINE rule75 #-}
   rule75 :: [Edge] -> [Edge] -> [Edge]
rule75 = \ (([Edge]
_hdIofld) :: [(Int, Int)]) (([Edge]
_tlIofld) :: [(Int, Int)]) ->
     (forall a. [a] -> [a] -> [a]
(++) [Edge]
_hdIofld [Edge]
_tlIofld)
   {-# INLINE rule76 #-}
   rule76 :: PMP -> PMP -> PMP
rule76 = \ ((PMP
_hdIpmp) :: PMP) ((PMP
_tlIpmp) :: PMP) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union PMP
_hdIpmp PMP
_tlIpmp)
   {-# INLINE rule77 #-}
   rule77 :: PMP_R -> PMP_R -> PMP_R
rule77 = \ ((PMP_R
_hdIpmpr) :: PMP_R) ((PMP_R
_tlIpmpr) :: PMP_R) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union PMP_R
_hdIpmpr PMP_R
_tlIpmpr)
   {-# INLINE rule78 #-}
   rule78 :: Set FLabel -> Set FLabel -> Set FLabel
rule78 = \ ((Set FLabel
_hdIpts) :: Set.Set FLabel) ((Set FLabel
_tlIpts) :: Set.Set FLabel) ->
     (forall a. Ord a => Set a -> Set a -> Set a
Set.union Set FLabel
_hdIpts Set FLabel
_tlIpts)
   {-# INLINE rule79 #-}
   rule79 :: Set NontermIdent -> Set NontermIdent -> Set NontermIdent
rule79 = \ ((Set NontermIdent
_hdIrefHoNts) :: Set NontermIdent) ((Set NontermIdent
_tlIrefHoNts) :: Set NontermIdent) ->
     Set NontermIdent
_hdIrefHoNts forall a. Monoid a => a -> a -> a
`mappend` Set NontermIdent
_tlIrefHoNts
   {-# INLINE rule80 #-}
   rule80 :: Set NontermIdent -> Set NontermIdent -> Set NontermIdent
rule80 = \ ((Set NontermIdent
_hdIrefNts) :: Set NontermIdent) ((Set NontermIdent
_tlIrefNts) :: Set NontermIdent) ->
     Set NontermIdent
_hdIrefNts forall a. Monoid a => a -> a -> a
`mappend` Set NontermIdent
_tlIrefNts
   {-# INLINE rule81 #-}
   rule81 :: Child -> Children -> Children
rule81 = \ ((Child
_hdIself) :: Child) ((Children
_tlIself) :: Children) ->
     (:) Child
_hdIself Children
_tlIself
   {-# INLINE rule82 #-}
   rule82 :: p -> p
rule82 = \ p
_self ->
     p
_self
   {-# INLINE rule83 #-}
   rule83 :: Int -> Int
rule83 = \ ((Int
_tlIflab) :: Int) ->
     Int
_tlIflab
   {-# INLINE rule84 #-}
   rule84 :: Int -> Int
rule84 = \ ((Int
_tlIolab) :: Int) ->
     Int
_tlIolab
   {-# INLINE rule85 #-}
   rule85 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule85 = \ ((MyType -> MyAttributes
_lhsIain) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIain
   {-# INLINE rule86 #-}
   rule86 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule86 = \ ((MyType -> MyAttributes
_lhsIan) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIan
   {-# INLINE rule87 #-}
   rule87 :: Map NontermIdent [Expression] -> Map NontermIdent [Expression]
rule87 = \ ((Map NontermIdent [Expression]
_lhsIaroundMap) :: Map Identifier [Expression]) ->
     Map NontermIdent [Expression]
_lhsIaroundMap
   {-# INLINE rule88 #-}
   rule88 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule88 = \ ((MyType -> MyAttributes
_lhsIasn) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIasn
   {-# INLINE rule89 #-}
   rule89 :: Int -> Int
rule89 = \ ((Int
_lhsIflab) :: Int) ->
     Int
_lhsIflab
   {-# INLINE rule90 #-}
   rule90 :: FTY -> FTY
rule90 = \ ((FTY
_lhsIfty) :: FTY) ->
     FTY
_lhsIfty
   {-# INLINE rule91 #-}
   rule91 :: HOMap -> HOMap
rule91 = \ ((HOMap
_lhsIhoMapf) :: HOMap) ->
     HOMap
_lhsIhoMapf
   {-# INLINE rule92 #-}
   rule92 :: SF_P -> SF_P
rule92 = \ ((SF_P
_lhsIlfpf) :: SF_P) ->
     SF_P
_lhsIlfpf
   {-# INLINE rule93 #-}
   rule93 :: Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
rule93 = \ ((Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap) :: Map Identifier (Identifier, [Identifier], Expression)) ->
     Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap
   {-# INLINE rule94 #-}
   rule94 :: Set NontermIdent -> Set NontermIdent
rule94 = \ ((Set NontermIdent
_lhsImergedChildren) :: Set Identifier) ->
     Set NontermIdent
_lhsImergedChildren
   {-# INLINE rule95 #-}
   rule95 :: NMP -> NMP
rule95 = \ ((NMP
_lhsInmp) :: NMP) ->
     NMP
_lhsInmp
   {-# INLINE rule96 #-}
   rule96 :: NMP_R -> NMP_R
rule96 = \ ((NMP_R
_lhsInmprf) :: NMP_R) ->
     NMP_R
_lhsInmprf
   {-# INLINE rule97 #-}
   rule97 :: Int -> Int
rule97 = \ ((Int
_lhsIolab) :: Int) ->
     Int
_lhsIolab
   {-# INLINE rule98 #-}
   rule98 :: Options -> Options
rule98 = \ ((Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# INLINE rule99 #-}
   rule99 :: PLabel -> PLabel
rule99 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule100 #-}
   rule100 :: PMP -> PMP
rule100 = \ ((PMP
_lhsIpmpf) :: PMP) ->
     PMP
_lhsIpmpf
   {-# INLINE rule101 #-}
   rule101 :: PMP_R -> PMP_R
rule101 = \ ((PMP_R
_lhsIpmprf) :: PMP_R) ->
     PMP_R
_lhsIpmprf
   {-# INLINE rule102 #-}
   rule102 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule102 = \ ((MyType -> MyAttributes
_lhsIain) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIain
   {-# INLINE rule103 #-}
   rule103 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule103 = \ ((MyType -> MyAttributes
_lhsIan) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIan
   {-# INLINE rule104 #-}
   rule104 :: Map NontermIdent [Expression] -> Map NontermIdent [Expression]
rule104 = \ ((Map NontermIdent [Expression]
_lhsIaroundMap) :: Map Identifier [Expression]) ->
     Map NontermIdent [Expression]
_lhsIaroundMap
   {-# INLINE rule105 #-}
   rule105 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule105 = \ ((MyType -> MyAttributes
_lhsIasn) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIasn
   {-# INLINE rule106 #-}
   rule106 :: MyType -> MyType
rule106 = \ ((MyType
_lhsIdty) :: MyType) ->
     MyType
_lhsIdty
   {-# INLINE rule107 #-}
   rule107 :: Int -> Int
rule107 = \ ((Int
_hdIflab) :: Int) ->
     Int
_hdIflab
   {-# INLINE rule108 #-}
   rule108 :: FTY -> FTY
rule108 = \ ((FTY
_hdIfty) :: FTY) ->
     FTY
_hdIfty
   {-# INLINE rule109 #-}
   rule109 :: HOMap -> HOMap
rule109 = \ ((HOMap
_lhsIhoMapf) :: HOMap) ->
     HOMap
_lhsIhoMapf
   {-# INLINE rule110 #-}
   rule110 :: SF_P -> SF_P
rule110 = \ ((SF_P
_lhsIlfpf) :: SF_P) ->
     SF_P
_lhsIlfpf
   {-# INLINE rule111 #-}
   rule111 :: Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
rule111 = \ ((Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap) :: Map Identifier (Identifier, [Identifier], Expression)) ->
     Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap
   {-# INLINE rule112 #-}
   rule112 :: Set NontermIdent -> Set NontermIdent
rule112 = \ ((Set NontermIdent
_lhsImergedChildren) :: Set Identifier) ->
     Set NontermIdent
_lhsImergedChildren
   {-# INLINE rule113 #-}
   rule113 :: NMP -> NMP
rule113 = \ ((NMP
_lhsInmp) :: NMP) ->
     NMP
_lhsInmp
   {-# INLINE rule114 #-}
   rule114 :: NMP_R -> NMP_R
rule114 = \ ((NMP_R
_lhsInmprf) :: NMP_R) ->
     NMP_R
_lhsInmprf
   {-# INLINE rule115 #-}
   rule115 :: Int -> Int
rule115 = \ ((Int
_hdIolab) :: Int) ->
     Int
_hdIolab
   {-# INLINE rule116 #-}
   rule116 :: Options -> Options
rule116 = \ ((Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# INLINE rule117 #-}
   rule117 :: PLabel -> PLabel
rule117 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule118 #-}
   rule118 :: PMP -> PMP
rule118 = \ ((PMP
_lhsIpmpf) :: PMP) ->
     PMP
_lhsIpmpf
   {-# INLINE rule119 #-}
   rule119 :: PMP_R -> PMP_R
rule119 = \ ((PMP_R
_lhsIpmprf) :: PMP_R) ->
     PMP_R
_lhsIpmprf
{-# NOINLINE sem_Children_Nil #-}
sem_Children_Nil ::  T_Children 
sem_Children_Nil :: T_Children
sem_Children_Nil  = Identity T_Children_s38 -> T_Children
T_Children (forall (m :: * -> *) a. Monad m => a -> m a
return T_Children_s38
st38) where
   {-# NOINLINE st38 #-}
   st38 :: T_Children_s38
st38 = let
      v37 :: T_Children_v37 
      v37 :: T_Children_v37
v37 = \ (T_Children_vIn37 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent [Expression]
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_lhsImergeMap Set NontermIdent
_lhsImergedChildren NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PLabel
_lhsIpll PMP
_lhsIpmpf PMP_R
_lhsIpmprf) -> ( let
         _fattsX47 :: T_FieldAtts_s47
_fattsX47 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_FieldAtts -> Identity T_FieldAtts_s47
attach_T_FieldAtts (([FieldAtt] -> T_FieldAtts
sem_FieldAtts [FieldAtt]
fatts_val_)))
         (T_FieldAtts_vOut46 A_P
_fattsIap Int
_fattsIflab FTY
_fattsIfty Map Int Int
_fattsIgen Map Int [Int]
_fattsIinss [Edge]
_fattsIofld Int
_fattsIolab PMP
_fattsIpmp PMP_R
_fattsIpmpr [FieldAtt]
_fattsIself) = T_FieldAtts_s47 -> T_FieldAtts_v46
inv_FieldAtts_s47 T_FieldAtts_s47
_fattsX47 ((MyType -> MyAttributes)
-> Int -> NMP_R -> Int -> T_FieldAtts_vIn46
T_FieldAtts_vIn46 MyType -> MyAttributes
_fattsOan Int
_fattsOflab NMP_R
_fattsOnmprf Int
_fattsOolab)
         _flab :: Int
_flab = Int -> Int
rule120 Int
_lhsIflab
         _atp :: MyType
_atp = PLabel -> MyType
rule121 PLabel
_lhsIpll
         fatts_val_ :: [FieldAtt]
fatts_val_ = MyType -> (MyType -> MyAttributes) -> PLabel -> [FieldAtt]
rule122 MyType
_atp MyType -> MyAttributes
_lhsIan PLabel
_lhsIpll
         _fattsOflab :: Int
_fattsOflab = forall a. a -> a
rule123 Int
_flab
         _label :: (PLabel, FLabel)
_label = PLabel -> (PLabel, FLabel)
rule124 PLabel
_lhsIpll
         _foccsI :: Set MyOccurrence
_foccsI = MyType
-> (PLabel, FLabel) -> (MyType -> MyAttributes) -> Set MyOccurrence
rule125 MyType
_atp (PLabel, FLabel)
_label MyType -> MyAttributes
_lhsIain
         _foccsS :: Set MyOccurrence
_foccsS = MyType
-> (PLabel, FLabel) -> (MyType -> MyAttributes) -> Set MyOccurrence
rule126 MyType
_atp (PLabel, FLabel)
_label MyType -> MyAttributes
_lhsIasn
         _fieldMap :: FMap
_fieldMap = forall {a} {b} {k}. a -> b -> k -> Map k (a, b)
rule127 Set MyOccurrence
_foccsI Set MyOccurrence
_foccsS (PLabel, FLabel)
_label
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = forall {k}. k -> MyType -> Map k MyType
rule128 (PLabel, FLabel)
_label MyType
_lhsIdty
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P
rule129 A_P
_fattsIap
         _lhsOechilds :: EChildren
         _lhsOechilds :: EChildren
_lhsOechilds = forall {a}. () -> [a]
rule130  ()
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = forall a. a -> a
rule131 FMap
_fieldMap
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int
rule132 Map Int Int
_fattsIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = forall {k} {a}. () -> Map k a
rule133  ()
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int]
rule134 Map Int [Int]
_fattsIinss
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge]
rule135 [Edge]
_fattsIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP
rule136 PMP
_fattsIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R
rule137 PMP_R
_fattsIpmpr
         _lhsOpts :: Set.Set FLabel
         _lhsOpts :: Set FLabel
_lhsOpts = forall {a}. () -> Set a
rule138  ()
         _lhsOrefHoNts :: Set NontermIdent
         _lhsOrefHoNts :: Set NontermIdent
_lhsOrefHoNts = () -> Set NontermIdent
rule139  ()
         _lhsOrefNts :: Set NontermIdent
         _lhsOrefNts :: Set NontermIdent
_lhsOrefNts = () -> Set NontermIdent
rule140  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule141  ()
         _lhsOself :: Children
         _lhsOself :: Children
_lhsOself = forall a. a -> a
rule142 forall a. [a]
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = forall a. a -> a
rule143 Int
_flab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule144 Int
_fattsIolab
         _fattsOan :: MyType -> MyAttributes
_fattsOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule145 MyType -> MyAttributes
_lhsIan
         _fattsOnmprf :: NMP_R
_fattsOnmprf = NMP_R -> NMP_R
rule146 NMP_R
_lhsInmprf
         _fattsOolab :: Int
_fattsOolab = Int -> Int
rule147 Int
_lhsIolab
         __result_ :: T_Children_vOut37
__result_ = A_P
-> EChildren
-> FMap
-> Int
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> Set FLabel
-> Set NontermIdent
-> Set NontermIdent
-> Children
-> T_Children_vOut37
T_Children_vOut37 A_P
_lhsOap EChildren
_lhsOechilds FMap
_lhsOfieldMap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr Set FLabel
_lhsOpts Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Children
_lhsOself
         in T_Children_vOut37
__result_ )
     in T_Children_v37 -> T_Children_s38
C_Children_s38 T_Children_v37
v37
   {-# INLINE rule120 #-}
   {-# LINE 161 "src-ag/LOAG/Prepare.ag" #-}
   rule120 = \ ((_lhsIflab) :: Int) ->
                    {-# LINE 161 "src-ag/LOAG/Prepare.ag" #-}
                    _lhsIflab + 1
                    {-# LINE 1611 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule121 #-}
   {-# LINE 162 "src-ag/LOAG/Prepare.ag" #-}
   rule121 = \ ((_lhsIpll) :: PLabel) ->
                    {-# LINE 162 "src-ag/LOAG/Prepare.ag" #-}
                    fst _lhsIpll
                    {-# LINE 1617 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule122 #-}
   {-# LINE 164 "src-ag/LOAG/Prepare.ag" #-}
   rule122 = \ _atp ((_lhsIan) :: MyType -> MyAttributes) ((_lhsIpll) :: PLabel) ->
                    {-# LINE 164 "src-ag/LOAG/Prepare.ag" #-}
                    map ((FieldAtt _atp     _lhsIpll "lhs") . alab) $
                          _lhsIan _atp
                    {-# LINE 1624 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule123 #-}
   {-# LINE 166 "src-ag/LOAG/Prepare.ag" #-}
   rule123 = \ _flab ->
                    {-# LINE 166 "src-ag/LOAG/Prepare.ag" #-}
                    _flab
                    {-# LINE 1630 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule124 #-}
   {-# LINE 167 "src-ag/LOAG/Prepare.ag" #-}
   rule124 = \ ((_lhsIpll) :: PLabel) ->
                    {-# LINE 167 "src-ag/LOAG/Prepare.ag" #-}
                    (_lhsIpll, "lhs")
                    {-# LINE 1636 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule125 #-}
   {-# LINE 168 "src-ag/LOAG/Prepare.ag" #-}
   rule125 = \ _atp _label ((_lhsIain) :: MyType -> MyAttributes) ->
                    {-# LINE 168 "src-ag/LOAG/Prepare.ag" #-}
                    Set.fromList $ handAllOut _label     $ _lhsIain _atp
                    {-# LINE 1642 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule126 #-}
   {-# LINE 169 "src-ag/LOAG/Prepare.ag" #-}
   rule126 = \ _atp _label ((_lhsIasn) :: MyType -> MyAttributes) ->
                    {-# LINE 169 "src-ag/LOAG/Prepare.ag" #-}
                    Set.fromList $ handAllOut _label     $ _lhsIasn _atp
                    {-# LINE 1648 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule127 #-}
   {-# LINE 170 "src-ag/LOAG/Prepare.ag" #-}
   rule127 = \ _foccsI _foccsS _label ->
                    {-# LINE 170 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton _label     (_foccsI    , _foccsS    )
                    {-# LINE 1654 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule128 #-}
   {-# LINE 171 "src-ag/LOAG/Prepare.ag" #-}
   rule128 = \ _label ((_lhsIdty) :: MyType) ->
                    {-# LINE 171 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton _label     _lhsIdty
                    {-# LINE 1660 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule129 #-}
   rule129 = \ ((_fattsIap) :: A_P) ->
     _fattsIap
   {-# INLINE rule130 #-}
   rule130 = \  (_ :: ()) ->
     []
   {-# INLINE rule131 #-}
   rule131 = \ _fieldMap ->
     _fieldMap
   {-# INLINE rule132 #-}
   rule132 = \ ((_fattsIgen) :: Map Int Int) ->
     _fattsIgen
   {-# INLINE rule133 #-}
   rule133 = \  (_ :: ()) ->
     Map.empty
   {-# INLINE rule134 #-}
   rule134 = \ ((_fattsIinss) :: Map Int [Int]) ->
     _fattsIinss
   {-# INLINE rule135 #-}
   rule135 = \ ((_fattsIofld) :: [(Int, Int)]) ->
     _fattsIofld
   {-# INLINE rule136 #-}
   rule136 = \ ((_fattsIpmp) :: PMP) ->
     _fattsIpmp
   {-# INLINE rule137 #-}
   rule137 = \ ((_fattsIpmpr) :: PMP_R) ->
     _fattsIpmpr
   {-# INLINE rule138 #-}
   rule138 = \  (_ :: ()) ->
     Set.empty
   {-# INLINE rule139 #-}
   rule139 = \  (_ :: ()) ->
     mempty
   {-# INLINE rule140 #-}
   rule140 = \  (_ :: ()) ->
     mempty
   {-# INLINE rule141 #-}
   rule141 = \  (_ :: ()) ->
     []
   {-# INLINE rule142 #-}
   rule142 = \ _self ->
     _self
   {-# INLINE rule143 #-}
   rule143 = \ _flab ->
     _flab
   {-# INLINE rule144 #-}
   rule144 = \ ((_fattsIolab) :: Int) ->
     _fattsIolab
   {-# INLINE rule145 #-}
   rule145 = \ ((_lhsIan) :: MyType -> MyAttributes) ->
     _lhsIan
   {-# INLINE rule146 #-}
   rule146 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule147 #-}
   rule147 = \ ((_lhsIolab) :: Int) ->
     _lhsIolab

-- Expression --------------------------------------------------
-- wrapper
data Inh_Expression  = Inh_Expression { Inh_Expression -> PLabel
pll_Inh_Expression :: (PLabel), Inh_Expression -> Set FLabel
pts_Inh_Expression :: (Set.Set (FLabel)) }
data Syn_Expression  = Syn_Expression { Syn_Expression -> Expression
copy_Syn_Expression :: (Expression), Syn_Expression -> Expression
self_Syn_Expression :: (Expression), Syn_Expression -> Set MyOccurrence
used_Syn_Expression :: (Set.Set MyOccurrence) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression  -> Inh_Expression  -> (Syn_Expression )
wrap_Expression :: T_Expression -> Inh_Expression -> Syn_Expression
wrap_Expression (T_Expression Identity T_Expression_s41
act) (Inh_Expression PLabel
_lhsIpll Set FLabel
_lhsIpts) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Expression_s41
sem <- Identity T_Expression_s41
act
        let arg40 :: T_Expression_vIn40
arg40 = PLabel -> Set FLabel -> T_Expression_vIn40
T_Expression_vIn40 PLabel
_lhsIpll Set FLabel
_lhsIpts
        (T_Expression_vOut40 Expression
_lhsOcopy Expression
_lhsOself Set MyOccurrence
_lhsOused) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Expression_s41 -> T_Expression_v40
inv_Expression_s41 T_Expression_s41
sem T_Expression_vIn40
arg40)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Expression -> Expression -> Set MyOccurrence -> Syn_Expression
Syn_Expression Expression
_lhsOcopy Expression
_lhsOself Set MyOccurrence
_lhsOused)
   )

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

-- semantic domain
newtype T_Expression  = T_Expression {
                                     T_Expression -> Identity T_Expression_s41
attach_T_Expression :: Identity (T_Expression_s41 )
                                     }
newtype T_Expression_s41  = C_Expression_s41 {
                                             T_Expression_s41 -> T_Expression_v40
inv_Expression_s41 :: (T_Expression_v40 )
                                             }
data T_Expression_s42  = C_Expression_s42
type T_Expression_v40  = (T_Expression_vIn40 ) -> (T_Expression_vOut40 )
data T_Expression_vIn40  = T_Expression_vIn40 (PLabel) (Set.Set (FLabel))
data T_Expression_vOut40  = T_Expression_vOut40 (Expression) (Expression) (Set.Set MyOccurrence)
{-# NOINLINE sem_Expression_Expression #-}
sem_Expression_Expression :: (Pos) -> ([HsToken]) ->  T_Expression 
sem_Expression_Expression :: Pos -> HsTokens -> T_Expression
sem_Expression_Expression Pos
arg_pos_ HsTokens
arg_tks_  = Identity T_Expression_s41 -> T_Expression
T_Expression (forall (m :: * -> *) a. Monad m => a -> m a
return T_Expression_s41
st41) where
   {-# NOINLINE st41 #-}
   st41 :: T_Expression_s41
st41 = let
      v40 :: T_Expression_v40 
      v40 :: T_Expression_v40
v40 = \ (T_Expression_vIn40 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _tokensX59 :: T_HsTokensRoot_s59
_tokensX59 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokensRoot -> Identity T_HsTokensRoot_s59
attach_T_HsTokensRoot ((HsTokensRoot -> T_HsTokensRoot
sem_HsTokensRoot HsTokensRoot
tokens_val_)))
         (T_HsTokensRoot_vOut58 HsTokensRoot
_tokensIself Set MyOccurrence
_tokensIused) = T_HsTokensRoot_s59 -> T_HsTokensRoot_v58
inv_HsTokensRoot_s59 T_HsTokensRoot_s59
_tokensX59 (PLabel -> Set FLabel -> T_HsTokensRoot_vIn58
T_HsTokensRoot_vIn58 PLabel
_tokensOpll Set FLabel
_tokensOpts)
         tokens_val_ :: HsTokensRoot
tokens_val_ = HsTokens -> HsTokensRoot
rule148 HsTokens
arg_tks_
         _tokensOpll :: PLabel
_tokensOpll = PLabel -> PLabel
rule149 PLabel
_lhsIpll
         _tokensOpts :: Set FLabel
_tokensOpts = Set FLabel -> Set FLabel
rule150 Set FLabel
_lhsIpts
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = Set MyOccurrence -> Set MyOccurrence
rule151 Set MyOccurrence
_tokensIused
         _copy :: Expression
_copy = Pos -> HsTokens -> Expression
rule152 Pos
arg_pos_ HsTokens
arg_tks_
         _self :: Expression
_self = Pos -> HsTokens -> Expression
rule153 Pos
arg_pos_ HsTokens
arg_tks_
         _lhsOcopy :: Expression
         _lhsOcopy :: Expression
_lhsOcopy = forall a. a -> a
rule154 Expression
_copy
         _lhsOself :: Expression
         _lhsOself :: Expression
_lhsOself = forall a. a -> a
rule155 Expression
_self
         __result_ :: T_Expression_vOut40
__result_ = Expression -> Expression -> Set MyOccurrence -> T_Expression_vOut40
T_Expression_vOut40 Expression
_lhsOcopy Expression
_lhsOself Set MyOccurrence
_lhsOused
         in T_Expression_vOut40
__result_ )
     in T_Expression_v40 -> T_Expression_s41
C_Expression_s41 T_Expression_v40
v40
   {-# INLINE rule148 #-}
   {-# LINE 273 "src-ag/LOAG/Prepare.ag" #-}
   rule148 = \ tks_ ->
                    {-# LINE 273 "src-ag/LOAG/Prepare.ag" #-}
                    HsTokensRoot tks_
                    {-# LINE 1777 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule149 #-}
   {-# LINE 274 "src-ag/LOAG/Prepare.ag" #-}
   rule149 = \ ((_lhsIpll) :: PLabel) ->
                    {-# LINE 274 "src-ag/LOAG/Prepare.ag" #-}
                    _lhsIpll
                    {-# LINE 1783 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule150 #-}
   {-# LINE 275 "src-ag/LOAG/Prepare.ag" #-}
   rule150 = \ ((_lhsIpts) :: Set.Set (FLabel)) ->
                    {-# LINE 275 "src-ag/LOAG/Prepare.ag" #-}
                    _lhsIpts
                    {-# LINE 1789 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule151 #-}
   {-# LINE 276 "src-ag/LOAG/Prepare.ag" #-}
   rule151 = \ ((_tokensIused) :: Set.Set MyOccurrence) ->
                    {-# LINE 276 "src-ag/LOAG/Prepare.ag" #-}
                    _tokensIused
                    {-# LINE 1795 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule152 #-}
   rule152 = \ pos_ tks_ ->
     Expression pos_ tks_
   {-# INLINE rule153 #-}
   rule153 = \ pos_ tks_ ->
     Expression pos_ tks_
   {-# INLINE rule154 #-}
   rule154 = \ _copy ->
     _copy
   {-# INLINE rule155 #-}
   rule155 = \ _self ->
     _self

-- FieldAtt ----------------------------------------------------
-- wrapper
data Inh_FieldAtt  = Inh_FieldAtt { Inh_FieldAtt -> MyType -> MyAttributes
an_Inh_FieldAtt :: (MyType -> MyAttributes), Inh_FieldAtt -> Int
flab_Inh_FieldAtt :: (Int), Inh_FieldAtt -> NMP_R
nmprf_Inh_FieldAtt :: (NMP_R), Inh_FieldAtt -> Int
olab_Inh_FieldAtt :: (Int) }
data Syn_FieldAtt  = Syn_FieldAtt { Syn_FieldAtt -> A_P
ap_Syn_FieldAtt :: (A_P), Syn_FieldAtt -> Int
flab_Syn_FieldAtt :: (Int), Syn_FieldAtt -> FTY
fty_Syn_FieldAtt :: (FTY), Syn_FieldAtt -> Map Int Int
gen_Syn_FieldAtt :: (Map Int Int), Syn_FieldAtt -> Map Int [Int]
inss_Syn_FieldAtt :: (Map Int [Int]), Syn_FieldAtt -> [Edge]
ofld_Syn_FieldAtt :: ([(Int, Int)]), Syn_FieldAtt -> Int
olab_Syn_FieldAtt :: (Int), Syn_FieldAtt -> PMP
pmp_Syn_FieldAtt :: (PMP), Syn_FieldAtt -> PMP_R
pmpr_Syn_FieldAtt :: (PMP_R), Syn_FieldAtt -> FieldAtt
self_Syn_FieldAtt :: (FieldAtt) }
{-# INLINABLE wrap_FieldAtt #-}
wrap_FieldAtt :: T_FieldAtt  -> Inh_FieldAtt  -> (Syn_FieldAtt )
wrap_FieldAtt :: T_FieldAtt -> Inh_FieldAtt -> Syn_FieldAtt
wrap_FieldAtt (T_FieldAtt Identity T_FieldAtt_s44
act) (Inh_FieldAtt MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_FieldAtt_s44
sem <- Identity T_FieldAtt_s44
act
        let arg43 :: T_FieldAtt_vIn43
arg43 = (MyType -> MyAttributes) -> Int -> NMP_R -> Int -> T_FieldAtt_vIn43
T_FieldAtt_vIn43 MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab
        (T_FieldAtt_vOut43 A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr FieldAtt
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_FieldAtt_s44 -> T_FieldAtt_v43
inv_FieldAtt_s44 T_FieldAtt_s44
sem T_FieldAtt_vIn43
arg43)
        forall (m :: * -> *) a. Monad m => a -> m a
return (A_P
-> Int
-> FTY
-> Map Int Int
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> FieldAtt
-> Syn_FieldAtt
Syn_FieldAtt A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr FieldAtt
_lhsOself)
   )

-- cata
{-# INLINE sem_FieldAtt #-}
sem_FieldAtt :: FieldAtt  -> T_FieldAtt 
sem_FieldAtt :: FieldAtt -> T_FieldAtt
sem_FieldAtt ( FieldAtt MyType
t_ PLabel
p_ FLabel
f_ (FLabel, Direction)
a_ ) = MyType -> PLabel -> FLabel -> (FLabel, Direction) -> T_FieldAtt
sem_FieldAtt_FieldAtt MyType
t_ PLabel
p_ FLabel
f_ (FLabel, Direction)
a_

-- semantic domain
newtype T_FieldAtt  = T_FieldAtt {
                                 T_FieldAtt -> Identity T_FieldAtt_s44
attach_T_FieldAtt :: Identity (T_FieldAtt_s44 )
                                 }
newtype T_FieldAtt_s44  = C_FieldAtt_s44 {
                                         T_FieldAtt_s44 -> T_FieldAtt_v43
inv_FieldAtt_s44 :: (T_FieldAtt_v43 )
                                         }
data T_FieldAtt_s45  = C_FieldAtt_s45
type T_FieldAtt_v43  = (T_FieldAtt_vIn43 ) -> (T_FieldAtt_vOut43 )
data T_FieldAtt_vIn43  = T_FieldAtt_vIn43 (MyType -> MyAttributes) (Int) (NMP_R) (Int)
data T_FieldAtt_vOut43  = T_FieldAtt_vOut43 (A_P) (Int) (FTY) (Map Int Int) (Map Int [Int]) ([(Int, Int)]) (Int) (PMP) (PMP_R) (FieldAtt)
{-# NOINLINE sem_FieldAtt_FieldAtt #-}
sem_FieldAtt_FieldAtt :: (MyType) -> (PLabel) -> (FLabel) -> (ALabel) -> T_FieldAtt 
sem_FieldAtt_FieldAtt :: MyType -> PLabel -> FLabel -> (FLabel, Direction) -> T_FieldAtt
sem_FieldAtt_FieldAtt MyType
arg_t_ PLabel
arg_p_ FLabel
arg_f_ (FLabel, Direction)
arg_a_ = Identity T_FieldAtt_s44 -> T_FieldAtt
T_FieldAtt (forall (m :: * -> *) a. Monad m => a -> m a
return T_FieldAtt_s44
st44) where
   {-# NOINLINE st44 #-}
   st44 :: T_FieldAtt_s44
st44 = let
      v43 :: T_FieldAtt_v43 
      v43 :: T_FieldAtt_v43
v43 = \ (T_FieldAtt_vIn43 MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab) -> ( let
         _olab :: Int
_olab = Int -> Int
rule156 Int
_lhsIolab
         _alab :: Int
_alab = MyAttribute -> NMP_R -> Int
rule157 MyAttribute
_att NMP_R
_lhsInmprf
         _att :: MyAttribute
_att = (FLabel, Direction) -> MyType -> MyAttribute
rule158 (FLabel, Direction)
arg_a_ MyType
arg_t_
         _occ :: MyOccurrence
_occ = (FLabel, Direction) -> FLabel -> PLabel -> MyOccurrence
rule159 (FLabel, Direction)
arg_a_ FLabel
arg_f_ PLabel
arg_p_
         _pmp :: PMP
_pmp = forall {a} {k}. a -> k -> Map k a
rule160 MyOccurrence
_occ Int
_olab
         _pmpr :: PMP_R
_pmpr = forall k a. k -> a -> Map k a
rule161 MyOccurrence
_occ Int
_olab
         _inss :: Map Int [Int]
_inss = forall {k} {a}. k -> a -> Map k [a]
rule162 Int
_alab Int
_olab
         _gen :: Map Int Int
_gen = forall {a} {k}. a -> k -> Map k a
rule163 Int
_alab Int
_olab
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = forall {a} {k}. a -> k -> Map k [a]
rule164 MyOccurrence
_occ PLabel
arg_p_
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = forall {a}. Int -> a -> [(a, Int)]
rule165 Int
_lhsIflab Int
_olab
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = forall {k} {a}. () -> Map k a
rule166  ()
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = forall a. a -> a
rule167 Map Int Int
_gen
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = forall a. a -> a
rule168 Map Int [Int]
_inss
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = forall a. a -> a
rule169 PMP
_pmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = forall a. a -> a
rule170 PMP_R
_pmpr
         _self :: FieldAtt
_self = (FLabel, Direction) -> FLabel -> PLabel -> MyType -> FieldAtt
rule171 (FLabel, Direction)
arg_a_ FLabel
arg_f_ PLabel
arg_p_ MyType
arg_t_
         _lhsOself :: FieldAtt
         _lhsOself :: FieldAtt
_lhsOself = forall a. a -> a
rule172 FieldAtt
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule173 Int
_lhsIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = forall a. a -> a
rule174 Int
_olab
         __result_ :: T_FieldAtt_vOut43
__result_ = A_P
-> Int
-> FTY
-> Map Int Int
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> FieldAtt
-> T_FieldAtt_vOut43
T_FieldAtt_vOut43 A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr FieldAtt
_lhsOself
         in T_FieldAtt_vOut43
__result_ )
     in T_FieldAtt_v43 -> T_FieldAtt_s44
C_FieldAtt_s44 T_FieldAtt_v43
v43
   {-# INLINE rule156 #-}
   {-# LINE 193 "src-ag/LOAG/Prepare.ag" #-}
   rule156 = \ ((_lhsIolab) :: Int) ->
                    {-# LINE 193 "src-ag/LOAG/Prepare.ag" #-}
                    _lhsIolab + 1
                    {-# LINE 1883 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule157 #-}
   {-# LINE 194 "src-ag/LOAG/Prepare.ag" #-}
   rule157 = \ _att ((_lhsInmprf) :: NMP_R) ->
                    {-# LINE 194 "src-ag/LOAG/Prepare.ag" #-}
                    findWithErr _lhsInmprf "getting attr label" _att
                    {-# LINE 1889 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule158 #-}
   {-# LINE 195 "src-ag/LOAG/Prepare.ag" #-}
   rule158 = \ a_ t_ ->
                    {-# LINE 195 "src-ag/LOAG/Prepare.ag" #-}
                    t_ <.> a_
                    {-# LINE 1895 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule159 #-}
   {-# LINE 196 "src-ag/LOAG/Prepare.ag" #-}
   rule159 = \ a_ f_ p_ ->
                    {-# LINE 196 "src-ag/LOAG/Prepare.ag" #-}
                    (p_, f_) >.< a_
                    {-# LINE 1901 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule160 #-}
   {-# LINE 197 "src-ag/LOAG/Prepare.ag" #-}
   rule160 = \ _occ _olab ->
                    {-# LINE 197 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton _olab     _occ
                    {-# LINE 1907 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule161 #-}
   {-# LINE 198 "src-ag/LOAG/Prepare.ag" #-}
   rule161 = \ _occ _olab ->
                    {-# LINE 198 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton _occ      _olab
                    {-# LINE 1913 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule162 #-}
   {-# LINE 199 "src-ag/LOAG/Prepare.ag" #-}
   rule162 = \ _alab _olab ->
                    {-# LINE 199 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton _alab     [_olab    ]
                    {-# LINE 1919 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule163 #-}
   {-# LINE 200 "src-ag/LOAG/Prepare.ag" #-}
   rule163 = \ _alab _olab ->
                    {-# LINE 200 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton _olab     _alab
                    {-# LINE 1925 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule164 #-}
   {-# LINE 201 "src-ag/LOAG/Prepare.ag" #-}
   rule164 = \ _occ p_ ->
                    {-# LINE 201 "src-ag/LOAG/Prepare.ag" #-}
                    Map.singleton p_ [_occ    ]
                    {-# LINE 1931 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule165 #-}
   {-# LINE 202 "src-ag/LOAG/Prepare.ag" #-}
   rule165 = \ ((_lhsIflab) :: Int) _olab ->
                    {-# LINE 202 "src-ag/LOAG/Prepare.ag" #-}
                    [(_olab    , _lhsIflab)]
                    {-# LINE 1937 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule166 #-}
   rule166 = \  (_ :: ()) ->
     Map.empty
   {-# INLINE rule167 #-}
   rule167 = \ _gen ->
     _gen
   {-# INLINE rule168 #-}
   rule168 = \ _inss ->
     _inss
   {-# INLINE rule169 #-}
   rule169 = \ _pmp ->
     _pmp
   {-# INLINE rule170 #-}
   rule170 = \ _pmpr ->
     _pmpr
   {-# INLINE rule171 #-}
   rule171 = \ a_ f_ p_ t_ ->
     FieldAtt t_ p_ f_ a_
   {-# INLINE rule172 #-}
   rule172 = \ _self ->
     _self
   {-# INLINE rule173 #-}
   rule173 = \ ((_lhsIflab) :: Int) ->
     _lhsIflab
   {-# INLINE rule174 #-}
   rule174 = \ _olab ->
     _olab

-- FieldAtts ---------------------------------------------------
-- wrapper
data Inh_FieldAtts  = Inh_FieldAtts { Inh_FieldAtts -> MyType -> MyAttributes
an_Inh_FieldAtts :: (MyType -> MyAttributes), Inh_FieldAtts -> Int
flab_Inh_FieldAtts :: (Int), Inh_FieldAtts -> NMP_R
nmprf_Inh_FieldAtts :: (NMP_R), Inh_FieldAtts -> Int
olab_Inh_FieldAtts :: (Int) }
data Syn_FieldAtts  = Syn_FieldAtts { Syn_FieldAtts -> A_P
ap_Syn_FieldAtts :: (A_P), Syn_FieldAtts -> Int
flab_Syn_FieldAtts :: (Int), Syn_FieldAtts -> FTY
fty_Syn_FieldAtts :: (FTY), Syn_FieldAtts -> Map Int Int
gen_Syn_FieldAtts :: (Map Int Int), Syn_FieldAtts -> Map Int [Int]
inss_Syn_FieldAtts :: (Map Int [Int]), Syn_FieldAtts -> [Edge]
ofld_Syn_FieldAtts :: ([(Int, Int)]), Syn_FieldAtts -> Int
olab_Syn_FieldAtts :: (Int), Syn_FieldAtts -> PMP
pmp_Syn_FieldAtts :: (PMP), Syn_FieldAtts -> PMP_R
pmpr_Syn_FieldAtts :: (PMP_R), Syn_FieldAtts -> [FieldAtt]
self_Syn_FieldAtts :: (FieldAtts) }
{-# INLINABLE wrap_FieldAtts #-}
wrap_FieldAtts :: T_FieldAtts  -> Inh_FieldAtts  -> (Syn_FieldAtts )
wrap_FieldAtts :: T_FieldAtts -> Inh_FieldAtts -> Syn_FieldAtts
wrap_FieldAtts (T_FieldAtts Identity T_FieldAtts_s47
act) (Inh_FieldAtts MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_FieldAtts_s47
sem <- Identity T_FieldAtts_s47
act
        let arg46 :: T_FieldAtts_vIn46
arg46 = (MyType -> MyAttributes)
-> Int -> NMP_R -> Int -> T_FieldAtts_vIn46
T_FieldAtts_vIn46 MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab
        (T_FieldAtts_vOut46 A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [FieldAtt]
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_FieldAtts_s47 -> T_FieldAtts_v46
inv_FieldAtts_s47 T_FieldAtts_s47
sem T_FieldAtts_vIn46
arg46)
        forall (m :: * -> *) a. Monad m => a -> m a
return (A_P
-> Int
-> FTY
-> Map Int Int
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [FieldAtt]
-> Syn_FieldAtts
Syn_FieldAtts A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [FieldAtt]
_lhsOself)
   )

-- cata
{-# NOINLINE sem_FieldAtts #-}
sem_FieldAtts :: FieldAtts  -> T_FieldAtts 
sem_FieldAtts :: [FieldAtt] -> T_FieldAtts
sem_FieldAtts [FieldAtt]
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_FieldAtt -> T_FieldAtts -> T_FieldAtts
sem_FieldAtts_Cons T_FieldAtts
sem_FieldAtts_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map FieldAtt -> T_FieldAtt
sem_FieldAtt [FieldAtt]
list)

-- semantic domain
newtype T_FieldAtts  = T_FieldAtts {
                                   T_FieldAtts -> Identity T_FieldAtts_s47
attach_T_FieldAtts :: Identity (T_FieldAtts_s47 )
                                   }
newtype T_FieldAtts_s47  = C_FieldAtts_s47 {
                                           T_FieldAtts_s47 -> T_FieldAtts_v46
inv_FieldAtts_s47 :: (T_FieldAtts_v46 )
                                           }
data T_FieldAtts_s48  = C_FieldAtts_s48
type T_FieldAtts_v46  = (T_FieldAtts_vIn46 ) -> (T_FieldAtts_vOut46 )
data T_FieldAtts_vIn46  = T_FieldAtts_vIn46 (MyType -> MyAttributes) (Int) (NMP_R) (Int)
data T_FieldAtts_vOut46  = T_FieldAtts_vOut46 (A_P) (Int) (FTY) (Map Int Int) (Map Int [Int]) ([(Int, Int)]) (Int) (PMP) (PMP_R) (FieldAtts)
{-# NOINLINE sem_FieldAtts_Cons #-}
sem_FieldAtts_Cons :: T_FieldAtt  -> T_FieldAtts  -> T_FieldAtts 
sem_FieldAtts_Cons :: T_FieldAtt -> T_FieldAtts -> T_FieldAtts
sem_FieldAtts_Cons T_FieldAtt
arg_hd_ T_FieldAtts
arg_tl_ = Identity T_FieldAtts_s47 -> T_FieldAtts
T_FieldAtts (forall (m :: * -> *) a. Monad m => a -> m a
return T_FieldAtts_s47
st47) where
   {-# NOINLINE st47 #-}
   st47 :: T_FieldAtts_s47
st47 = let
      v46 :: T_FieldAtts_v46 
      v46 :: T_FieldAtts_v46
v46 = \ (T_FieldAtts_vIn46 MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab) -> ( let
         _hdX44 :: T_FieldAtt_s44
_hdX44 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_FieldAtt -> Identity T_FieldAtt_s44
attach_T_FieldAtt (T_FieldAtt
arg_hd_))
         _tlX47 :: T_FieldAtts_s47
_tlX47 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_FieldAtts -> Identity T_FieldAtts_s47
attach_T_FieldAtts (T_FieldAtts
arg_tl_))
         (T_FieldAtt_vOut43 A_P
_hdIap Int
_hdIflab FTY
_hdIfty Map Int Int
_hdIgen Map Int [Int]
_hdIinss [Edge]
_hdIofld Int
_hdIolab PMP
_hdIpmp PMP_R
_hdIpmpr FieldAtt
_hdIself) = T_FieldAtt_s44 -> T_FieldAtt_v43
inv_FieldAtt_s44 T_FieldAtt_s44
_hdX44 ((MyType -> MyAttributes) -> Int -> NMP_R -> Int -> T_FieldAtt_vIn43
T_FieldAtt_vIn43 MyType -> MyAttributes
_hdOan Int
_hdOflab NMP_R
_hdOnmprf Int
_hdOolab)
         (T_FieldAtts_vOut46 A_P
_tlIap Int
_tlIflab FTY
_tlIfty Map Int Int
_tlIgen Map Int [Int]
_tlIinss [Edge]
_tlIofld Int
_tlIolab PMP
_tlIpmp PMP_R
_tlIpmpr [FieldAtt]
_tlIself) = T_FieldAtts_s47 -> T_FieldAtts_v46
inv_FieldAtts_s47 T_FieldAtts_s47
_tlX47 ((MyType -> MyAttributes)
-> Int -> NMP_R -> Int -> T_FieldAtts_vIn46
T_FieldAtts_vIn46 MyType -> MyAttributes
_tlOan Int
_tlOflab NMP_R
_tlOnmprf Int
_tlOolab)
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P -> A_P
rule175 A_P
_hdIap A_P
_tlIap
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = FTY -> FTY -> FTY
rule176 FTY
_hdIfty FTY
_tlIfty
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int -> Map Int Int
rule177 Map Int Int
_hdIgen Map Int Int
_tlIgen
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule178 Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge] -> [Edge]
rule179 [Edge]
_hdIofld [Edge]
_tlIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP -> PMP
rule180 PMP
_hdIpmp PMP
_tlIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R -> PMP_R
rule181 PMP_R
_hdIpmpr PMP_R
_tlIpmpr
         _self :: [FieldAtt]
_self = FieldAtt -> [FieldAtt] -> [FieldAtt]
rule182 FieldAtt
_hdIself [FieldAtt]
_tlIself
         _lhsOself :: FieldAtts
         _lhsOself :: [FieldAtt]
_lhsOself = forall a. a -> a
rule183 [FieldAtt]
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule184 Int
_tlIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule185 Int
_tlIolab
         _hdOan :: MyType -> MyAttributes
_hdOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule186 MyType -> MyAttributes
_lhsIan
         _hdOflab :: Int
_hdOflab = Int -> Int
rule187 Int
_lhsIflab
         _hdOnmprf :: NMP_R
_hdOnmprf = NMP_R -> NMP_R
rule188 NMP_R
_lhsInmprf
         _hdOolab :: Int
_hdOolab = Int -> Int
rule189 Int
_lhsIolab
         _tlOan :: MyType -> MyAttributes
_tlOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule190 MyType -> MyAttributes
_lhsIan
         _tlOflab :: Int
_tlOflab = Int -> Int
rule191 Int
_hdIflab
         _tlOnmprf :: NMP_R
_tlOnmprf = NMP_R -> NMP_R
rule192 NMP_R
_lhsInmprf
         _tlOolab :: Int
_tlOolab = Int -> Int
rule193 Int
_hdIolab
         __result_ :: T_FieldAtts_vOut46
__result_ = A_P
-> Int
-> FTY
-> Map Int Int
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [FieldAtt]
-> T_FieldAtts_vOut46
T_FieldAtts_vOut46 A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [FieldAtt]
_lhsOself
         in T_FieldAtts_vOut46
__result_ )
     in T_FieldAtts_v46 -> T_FieldAtts_s47
C_FieldAtts_s47 T_FieldAtts_v46
v46
   {-# INLINE rule175 #-}
   rule175 :: A_P -> A_P -> A_P
rule175 = \ ((A_P
_hdIap) :: A_P) ((A_P
_tlIap) :: A_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith forall a. [a] -> [a] -> [a]
(++) A_P
_hdIap A_P
_tlIap)
   {-# INLINE rule176 #-}
   rule176 :: FTY -> FTY -> FTY
rule176 = \ ((FTY
_hdIfty) :: FTY) ((FTY
_tlIfty) :: FTY) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union FTY
_hdIfty FTY
_tlIfty)
   {-# INLINE rule177 #-}
   rule177 :: Map Int Int -> Map Int Int -> Map Int Int
rule177 = \ ((Map Int Int
_hdIgen) :: Map Int Int) ((Map Int Int
_tlIgen) :: Map Int Int) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map Int Int
_hdIgen Map Int Int
_tlIgen)
   {-# INLINE rule178 #-}
   rule178 :: Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule178 = \ ((Map Int [Int]
_hdIinss) :: Map Int [Int]) ((Map Int [Int]
_tlIinss) :: Map Int [Int]) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith forall a. [a] -> [a] -> [a]
(++) Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss)
   {-# INLINE rule179 #-}
   rule179 :: [Edge] -> [Edge] -> [Edge]
rule179 = \ (([Edge]
_hdIofld) :: [(Int, Int)]) (([Edge]
_tlIofld) :: [(Int, Int)]) ->
     (forall a. [a] -> [a] -> [a]
(++) [Edge]
_hdIofld [Edge]
_tlIofld)
   {-# INLINE rule180 #-}
   rule180 :: PMP -> PMP -> PMP
rule180 = \ ((PMP
_hdIpmp) :: PMP) ((PMP
_tlIpmp) :: PMP) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union PMP
_hdIpmp PMP
_tlIpmp)
   {-# INLINE rule181 #-}
   rule181 :: PMP_R -> PMP_R -> PMP_R
rule181 = \ ((PMP_R
_hdIpmpr) :: PMP_R) ((PMP_R
_tlIpmpr) :: PMP_R) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union PMP_R
_hdIpmpr PMP_R
_tlIpmpr)
   {-# INLINE rule182 #-}
   rule182 :: FieldAtt -> [FieldAtt] -> [FieldAtt]
rule182 = \ ((FieldAtt
_hdIself) :: FieldAtt) (([FieldAtt]
_tlIself) :: FieldAtts) ->
     (:) FieldAtt
_hdIself [FieldAtt]
_tlIself
   {-# INLINE rule183 #-}
   rule183 :: p -> p
rule183 = \ p
_self ->
     p
_self
   {-# INLINE rule184 #-}
   rule184 :: Int -> Int
rule184 = \ ((Int
_tlIflab) :: Int) ->
     Int
_tlIflab
   {-# INLINE rule185 #-}
   rule185 :: Int -> Int
rule185 = \ ((Int
_tlIolab) :: Int) ->
     Int
_tlIolab
   {-# INLINE rule186 #-}
   rule186 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule186 = \ ((MyType -> MyAttributes
_lhsIan) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIan
   {-# INLINE rule187 #-}
   rule187 :: Int -> Int
rule187 = \ ((Int
_lhsIflab) :: Int) ->
     Int
_lhsIflab
   {-# INLINE rule188 #-}
   rule188 :: NMP_R -> NMP_R
rule188 = \ ((NMP_R
_lhsInmprf) :: NMP_R) ->
     NMP_R
_lhsInmprf
   {-# INLINE rule189 #-}
   rule189 :: Int -> Int
rule189 = \ ((Int
_lhsIolab) :: Int) ->
     Int
_lhsIolab
   {-# INLINE rule190 #-}
   rule190 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule190 = \ ((MyType -> MyAttributes
_lhsIan) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIan
   {-# INLINE rule191 #-}
   rule191 :: Int -> Int
rule191 = \ ((Int
_hdIflab) :: Int) ->
     Int
_hdIflab
   {-# INLINE rule192 #-}
   rule192 :: NMP_R -> NMP_R
rule192 = \ ((NMP_R
_lhsInmprf) :: NMP_R) ->
     NMP_R
_lhsInmprf
   {-# INLINE rule193 #-}
   rule193 :: Int -> Int
rule193 = \ ((Int
_hdIolab) :: Int) ->
     Int
_hdIolab
{-# NOINLINE sem_FieldAtts_Nil #-}
sem_FieldAtts_Nil ::  T_FieldAtts 
sem_FieldAtts_Nil :: T_FieldAtts
sem_FieldAtts_Nil  = Identity T_FieldAtts_s47 -> T_FieldAtts
T_FieldAtts (forall (m :: * -> *) a. Monad m => a -> m a
return T_FieldAtts_s47
st47) where
   {-# NOINLINE st47 #-}
   st47 :: T_FieldAtts_s47
st47 = let
      v46 :: T_FieldAtts_v46 
      v46 :: T_FieldAtts_v46
v46 = \ (T_FieldAtts_vIn46 MyType -> MyAttributes
_lhsIan Int
_lhsIflab NMP_R
_lhsInmprf Int
_lhsIolab) -> ( let
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = forall {k} {a}. () -> Map k a
rule194  ()
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = forall {k} {a}. () -> Map k a
rule195  ()
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = forall {k} {a}. () -> Map k a
rule196  ()
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = forall {k} {a}. () -> Map k a
rule197  ()
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = forall {a}. () -> [a]
rule198  ()
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = forall {k} {a}. () -> Map k a
rule199  ()
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = forall {k} {a}. () -> Map k a
rule200  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule201  ()
         _lhsOself :: FieldAtts
         _lhsOself :: [FieldAtt]
_lhsOself = forall a. a -> a
rule202 forall a. [a]
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule203 Int
_lhsIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule204 Int
_lhsIolab
         __result_ :: T_FieldAtts_vOut46
__result_ = A_P
-> Int
-> FTY
-> Map Int Int
-> Map Int [Int]
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [FieldAtt]
-> T_FieldAtts_vOut46
T_FieldAtts_vOut46 A_P
_lhsOap Int
_lhsOflab FTY
_lhsOfty Map Int Int
_lhsOgen Map Int [Int]
_lhsOinss [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [FieldAtt]
_lhsOself
         in T_FieldAtts_vOut46
__result_ )
     in T_FieldAtts_v46 -> T_FieldAtts_s47
C_FieldAtts_s47 T_FieldAtts_v46
v46
   {-# INLINE rule194 #-}
   rule194 :: () -> Map k a
rule194 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule195 #-}
   rule195 :: () -> Map k a
rule195 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule196 #-}
   rule196 :: () -> Map k a
rule196 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule197 #-}
   rule197 :: () -> Map k a
rule197 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule198 #-}
   rule198 :: () -> [a]
rule198 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule199 #-}
   rule199 :: () -> Map k a
rule199 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule200 #-}
   rule200 :: () -> Map k a
rule200 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule201 #-}
   rule201 :: () -> [a]
rule201 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule202 #-}
   rule202 :: p -> p
rule202 = \ p
_self ->
     p
_self
   {-# INLINE rule203 #-}
   rule203 :: Int -> Int
rule203 = \ ((Int
_lhsIflab) :: Int) ->
     Int
_lhsIflab
   {-# INLINE rule204 #-}
   rule204 :: Int -> Int
rule204 = \ ((Int
_lhsIolab) :: Int) ->
     Int
_lhsIolab

-- Grammar -----------------------------------------------------
-- wrapper
data Inh_Grammar  = Inh_Grammar { Inh_Grammar -> Options
options_Inh_Grammar :: (Options) }
data Syn_Grammar  = Syn_Grammar { Syn_Grammar -> Maybe PP_Doc
ads_Syn_Grammar :: (Maybe PP_Doc), Syn_Grammar -> Seq Error
errors_Syn_Grammar :: (Seq.Seq Error), Syn_Grammar -> Map NontermIdent (Map NontermIdent Type)
inhmap_Syn_Grammar :: (Map.Map NontermIdent Attributes), Syn_Grammar
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
localSigMap_Syn_Grammar :: (Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))), Syn_Grammar -> ExecutionPlan
output_Syn_Grammar :: (ExecutionPlan), Syn_Grammar -> Grammar
self_Syn_Grammar :: (Grammar), Syn_Grammar -> Map NontermIdent (Map NontermIdent Type)
synmap_Syn_Grammar :: (Map.Map NontermIdent Attributes) }
{-# INLINABLE wrap_Grammar #-}
wrap_Grammar :: T_Grammar  -> Inh_Grammar  -> (Syn_Grammar )
wrap_Grammar :: T_Grammar -> Inh_Grammar -> Syn_Grammar
wrap_Grammar (T_Grammar Identity T_Grammar_s50
act) (Inh_Grammar Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Grammar_s50
sem <- Identity T_Grammar_s50
act
        let arg49 :: T_Grammar_vIn49
arg49 = Options -> T_Grammar_vIn49
T_Grammar_vIn49 Options
_lhsIoptions
        (T_Grammar_vOut49 Maybe PP_Doc
_lhsOads Seq Error
_lhsOerrors Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap ExecutionPlan
_lhsOoutput Grammar
_lhsOself Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Grammar_s50 -> T_Grammar_v49
inv_Grammar_s50 T_Grammar_s50
sem T_Grammar_vIn49
arg49)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe PP_Doc
-> Seq Error
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> ExecutionPlan
-> Grammar
-> Map NontermIdent (Map NontermIdent Type)
-> Syn_Grammar
Syn_Grammar Maybe PP_Doc
_lhsOads Seq Error
_lhsOerrors Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap ExecutionPlan
_lhsOoutput Grammar
_lhsOself Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap)
   )

-- cata
{-# INLINE sem_Grammar #-}
sem_Grammar :: Grammar  -> T_Grammar 
sem_Grammar :: Grammar -> T_Grammar
sem_Grammar ( Grammar TypeSyns
typeSyns_ UseMap
useMap_ Map NontermIdent (Set NontermIdent)
derivings_ Set NontermIdent
wrappers_ Nonterminals
nonts_ PragmaMap
pragmas_ AttrOrderMap
manualAttrOrderMap_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ UniqueMap
uniqueMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
augmentsMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
mergeMap_  ) = TypeSyns
-> UseMap
-> Map NontermIdent (Set NontermIdent)
-> Set NontermIdent
-> T_Nonterminals
-> PragmaMap
-> AttrOrderMap
-> ParamMap
-> ContextMap
-> QuantMap
-> UniqueMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> T_Grammar
sem_Grammar_Grammar TypeSyns
typeSyns_ UseMap
useMap_ Map NontermIdent (Set NontermIdent)
derivings_ Set NontermIdent
wrappers_ ( Nonterminals -> T_Nonterminals
sem_Nonterminals Nonterminals
nonts_ ) PragmaMap
pragmas_ AttrOrderMap
manualAttrOrderMap_ ParamMap
paramMap_ ContextMap
contextMap_ QuantMap
quantMap_ UniqueMap
uniqueMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
augmentsMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
mergeMap_ 

-- semantic domain
newtype T_Grammar  = T_Grammar {
                               T_Grammar -> Identity T_Grammar_s50
attach_T_Grammar :: Identity (T_Grammar_s50 )
                               }
newtype T_Grammar_s50  = C_Grammar_s50 {
                                       T_Grammar_s50 -> T_Grammar_v49
inv_Grammar_s50 :: (T_Grammar_v49 )
                                       }
data T_Grammar_s51  = C_Grammar_s51
type T_Grammar_v49  = (T_Grammar_vIn49 ) -> (T_Grammar_vOut49 )
data T_Grammar_vIn49  = T_Grammar_vIn49 (Options)
data T_Grammar_vOut49  = T_Grammar_vOut49 (Maybe PP_Doc) (Seq.Seq Error) (Map.Map NontermIdent Attributes) (Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))) (ExecutionPlan) (Grammar) (Map.Map NontermIdent Attributes)
{-# 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 :: TypeSyns
-> UseMap
-> Map NontermIdent (Set NontermIdent)
-> Set NontermIdent
-> T_Nonterminals
-> PragmaMap
-> AttrOrderMap
-> ParamMap
-> ContextMap
-> QuantMap
-> UniqueMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> T_Grammar
sem_Grammar_Grammar TypeSyns
arg_typeSyns_ UseMap
arg_useMap_ Map NontermIdent (Set NontermIdent)
arg_derivings_ Set NontermIdent
arg_wrappers_ T_Nonterminals
arg_nonts_ PragmaMap
arg_pragmas_ AttrOrderMap
arg_manualAttrOrderMap_ ParamMap
arg_paramMap_ ContextMap
arg_contextMap_ QuantMap
arg_quantMap_ UniqueMap
arg_uniqueMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_augmentsMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_aroundsMap_ Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
arg_mergeMap_  = Identity T_Grammar_s50 -> T_Grammar
T_Grammar (forall (m :: * -> *) a. Monad m => a -> m a
return T_Grammar_s50
st50) where
   {-# NOINLINE st50 #-}
   st50 :: T_Grammar_s50
st50 = let
      v49 :: T_Grammar_v49 
      v49 :: T_Grammar_v49
v49 = \ (T_Grammar_vIn49 Options
_lhsIoptions) -> ( let
         _nontsX74 :: T_Nonterminals_s74
_nontsX74 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s74
attach_T_Nonterminals (T_Nonterminals
arg_nonts_))
         _smfX62 :: T_LOAGRep_s62
_smfX62 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_LOAGRep -> Identity T_LOAGRep_s62
attach_T_LOAGRep ((LOAGRep -> T_LOAGRep
sem_LOAGRep LOAGRep
smf_val_)))
         (T_Nonterminals_vOut73 [Edge]
_nontsIads A_P
_nontsIap ENonterminals
_nontsIenonts AttrOrderMap
_nontsIfdps FMap
_nontsIfieldMap Int
_nontsIflab Map PLabel [(PLabel, FLabel)]
_nontsIfsInP FTY
_nontsIfty Map Int Int
_nontsIgen HOMap
_nontsIhoMap Map NontermIdent (Map NontermIdent Type)
_nontsIinhmap AI_N
_nontsIinhs Map Int [Int]
_nontsIinss SF_P
_nontsIlfp SF_P
_nontsIlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_nontsIlocalSigMap Map NontermIdent (Set NontermIdent)
_nontsIntDeps Map NontermIdent (Set NontermIdent)
_nontsIntHoDeps [Edge]
_nontsIofld Int
_nontsIolab PMP
_nontsIpmp PMP_R
_nontsIpmpr [PLabel]
_nontsIps Map MyOccurrence NontermIdent
_nontsIruleMap Int
_nontsIrulenumber Nonterminals
_nontsIself SF_P
_nontsIsfp Map NontermIdent (Map NontermIdent Type)
_nontsIsynmap AI_N
_nontsIsyns IntMap Int
_nontsIvisMap Int
_nontsIvisitnum) = T_Nonterminals_s74 -> T_Nonterminals_v73
inv_Nonterminals_s74 T_Nonterminals_s74
_nontsX74 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> (MyType -> MyAttributes)
-> AttrOrderMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> InterfaceRes
-> TDPRes
-> IntMap Int
-> Int
-> T_Nonterminals_vIn73
T_Nonterminals_vIn73 MyType -> MyAttributes
_nontsOain MyType -> MyAttributes
_nontsOan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_nontsOaroundMap MyType -> MyAttributes
_nontsOasn AttrOrderMap
_nontsOaugM ContextMap
_nontsOclassContexts Map NontermIdent (Set NontermIdent)
_nontsOclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_nontsOclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_nontsOclosedNtDeps Int
_nontsOflab FTY
_nontsOfty FTY
_nontsOftyf HOMap
_nontsOhoMapf SF_P
_nontsOlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_nontsOmergeMap NMP
_nontsOnmp NMP_R
_nontsOnmprf Int
_nontsOolab Options
_nontsOoptions PMP
_nontsOpmpf PMP_R
_nontsOpmprf [Edge]
_nontsOres_ads Int
_nontsOrulenumber InterfaceRes
_nontsOsched TDPRes
_nontsOtdp IntMap Int
_nontsOvisMapf Int
_nontsOvisitnum)
         (T_LOAGRep_vOut61 LOAGRep
_smfIself) = T_LOAGRep_s62 -> T_LOAGRep_v61
inv_LOAGRep_s62 T_LOAGRep_s62
_smfX62 (T_LOAGRep_vIn61
T_LOAGRep_vIn61 )
         _closedNtDeps :: Map NontermIdent (Set NontermIdent)
_closedNtDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule205 Map NontermIdent (Set NontermIdent)
_nontsIntDeps
         _closedHoNtDeps :: Map NontermIdent (Set NontermIdent)
_closedHoNtDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule206 Map NontermIdent (Set NontermIdent)
_nontsIntHoDeps
         _closedHoNtRevDeps :: Map NontermIdent (Set NontermIdent)
_closedHoNtRevDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule207 Map NontermIdent (Set NontermIdent)
_closedHoNtDeps
         _nontsOclassContexts :: ContextMap
_nontsOclassContexts = forall a. a -> a
rule208 ContextMap
arg_contextMap_
         _nontsOaroundMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_nontsOaroundMap = forall a. a -> a
rule209 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_aroundsMap_
         _nontsOmergeMap :: Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_nontsOmergeMap = forall a. a -> a
rule210 Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
arg_mergeMap_
         _nontsOrulenumber :: Int
_nontsOrulenumber = () -> Int
rule211  ()
         _initO :: Int
_initO = PMP -> Int
rule212 PMP
_nontsIpmp
         smf_val_ :: LOAGRep
smf_val_ = AI_N
-> AI_N
-> AI_N
-> Int
-> NMP
-> NMP_R
-> A_P
-> FMap
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> Map Int [Int]
-> [Edge]
-> PMP
-> PMP_R
-> [PLabel]
-> SF_P
-> LOAGRep
rule213 AI_N
_ain AI_N
_an AI_N
_asn Int
_initO NMP
_nmp NMP_R
_nmpr A_P
_nontsIap FMap
_nontsIfieldMap Map PLabel [(PLabel, FLabel)]
_nontsIfsInP FTY
_nontsIfty Map Int Int
_nontsIgen Map Int [Int]
_nontsIinss [Edge]
_nontsIofld PMP
_nontsIpmp PMP_R
_nontsIpmpr [PLabel]
_nontsIps SF_P
_sfp
         _nmp :: NMP
_nmp = forall {a}. [a] -> Map Int a
rule214 MyAttributes
_atts
         _nmpr :: NMP_R
_nmpr = MyAttributes -> NMP_R
rule215 MyAttributes
_atts
         _an :: AI_N
_an = forall {a}. Map MyType [a] -> Map MyType [a] -> Map MyType [a]
rule216 AI_N
_ain AI_N
_asn
         _ain :: AI_N
_ain = AI_N -> AI_N
rule217 AI_N
_nontsIinhs
         _asn :: AI_N
_asn = AI_N -> AI_N
rule218 AI_N
_nontsIsyns
         _atts :: MyAttributes
_atts = forall {k} {a}. Map k [a] -> [a]
rule219 AI_N
_an
         _occs :: [MyOccurrence]
_occs = A_P -> [MyOccurrence]
rule220 A_P
_nontsIap
         _nontsOaugM :: AttrOrderMap
_nontsOaugM = forall a. a -> a
rule221 AttrOrderMap
arg_manualAttrOrderMap_
         _nontsOain :: MyType -> MyAttributes
_nontsOain = forall {b}. Map MyType [b] -> MyType -> [b]
rule222 AI_N
_ain
         _nontsOasn :: MyType -> MyAttributes
_nontsOasn = forall {b}. Map MyType [b] -> MyType -> [b]
rule223 AI_N
_asn
         _nontsOpmpf :: PMP
_nontsOpmpf = PMP -> PMP
rule224 PMP
_nontsIpmp
         _nontsOpmprf :: PMP_R
_nontsOpmprf = PMP_R -> PMP_R
rule225 PMP_R
_nontsIpmpr
         _nontsOlfpf :: SF_P
_nontsOlfpf = SF_P -> SF_P
rule226 SF_P
_nontsIlfp
         _nontsOhoMapf :: HOMap
_nontsOhoMapf = HOMap -> HOMap
rule227 HOMap
_nontsIhoMap
         _nontsOftyf :: FTY
_nontsOftyf = FTY -> FTY
rule228 FTY
_nontsIfty
         _nontsOfty :: FTY
_nontsOfty = FTY -> FTY
rule229 FTY
_nontsIfty
         _ps :: [PLabel]
_ps = [PLabel] -> [PLabel]
rule230 [PLabel]
_nontsIps
         _nontsOan :: MyType -> MyAttributes
_nontsOan = forall {b}. Map MyType [b] -> MyType -> [b]
rule231 AI_N
_an
         _nontsOnmprf :: NMP_R
_nontsOnmprf = forall a. a -> a
rule232 NMP_R
_nmpr
         _nontsOolab :: Int
_nontsOolab = forall {b}. Map Int b -> Int
rule233 NMP
_nmp
         _nontsOflab :: Int
_nontsOflab = () -> Int
rule234  ()
         _sfp :: SF_P
_sfp = SF_P -> SF_P -> SF_P
rule235 SF_P
_nontsIlfp SF_P
_nontsIsfp
         _lhsOerrors :: Seq.Seq Error
         _lhsOerrors :: Seq Error
_lhsOerrors = forall {a} {b}. Either a b -> Seq a
rule236 AOAGRes
_schedRes
         _lhsOads :: Maybe PP_Doc
         _lhsOads :: Maybe PP_Doc
_lhsOads = forall {a} {a} {b}.
Options -> PMP -> Either a (a, b, [Edge]) -> Maybe PP_Doc
rule237 Options
_lhsIoptions PMP
_nontsIpmp AOAGRes
_schedRes
         _lhsOoutput :: ExecutionPlan
         _lhsOoutput :: ExecutionPlan
_lhsOoutput = ENonterminals
-> Map NontermIdent (Set NontermIdent)
-> TypeSyns
-> Set NontermIdent
-> ExecutionPlan
rule238 ENonterminals
_nontsIenonts Map NontermIdent (Set NontermIdent)
arg_derivings_ TypeSyns
arg_typeSyns_ Set NontermIdent
arg_wrappers_
         _nontsOsched :: InterfaceRes
_nontsOsched = forall {a} {a} {k} {a} {c}. Either a (a, Map k a, c) -> Map k a
rule239 AOAGRes
_schedRes
         _nontsOtdp :: TDPRes
_nontsOtdp = forall {a} {c} {b} {c}. Either a (Maybe c, b, c) -> c
rule240 AOAGRes
_schedRes
         _schedRes :: AOAGRes
_schedRes = Ag -> Options -> AOAGRes -> [Edge] -> Grammar -> LOAGRep -> AOAGRes
rule241 Ag
_ag Options
_lhsIoptions AOAGRes
_loagRes [Edge]
_nontsIads Grammar
_self LOAGRep
_smfIself
         _loagRes :: AOAGRes
_loagRes = forall {t} {a} {b}. t -> Options -> Either a b
rule242 Ag
_ag Options
_lhsIoptions
         _ag :: Ag
_ag = Grammar -> LOAGRep -> Ag
rule243 Grammar
_self LOAGRep
_smfIself
         _nontsOres_ads :: [Edge]
_nontsOres_ads = forall {a} {a} {b} {a}. Either a (a, b, [a]) -> [a]
rule244 AOAGRes
_schedRes
         _nontsOvisMapf :: IntMap Int
_nontsOvisMapf = IntMap Int -> IntMap Int
rule245 IntMap Int
_nontsIvisMap
         _nontsOvisitnum :: Int
_nontsOvisitnum = () -> Int
rule246  ()
         _lhsOinhmap :: Map.Map NontermIdent Attributes
         _lhsOinhmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap = Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule247 Map NontermIdent (Map NontermIdent Type)
_nontsIinhmap
         _lhsOlocalSigMap :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap = Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
rule248 Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_nontsIlocalSigMap
         _lhsOsynmap :: Map.Map NontermIdent Attributes
         _lhsOsynmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap = Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule249 Map NontermIdent (Map NontermIdent Type)
_nontsIsynmap
         _self :: Grammar
_self = Nonterminals
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> AttrOrderMap
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> ParamMap
-> PragmaMap
-> QuantMap
-> TypeSyns
-> UniqueMap
-> UseMap
-> Set NontermIdent
-> Grammar
rule250 Nonterminals
_nontsIself Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_aroundsMap_ Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_augmentsMap_ ContextMap
arg_contextMap_ Map NontermIdent (Set NontermIdent)
arg_derivings_ AttrOrderMap
arg_manualAttrOrderMap_ Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
arg_mergeMap_ ParamMap
arg_paramMap_ PragmaMap
arg_pragmas_ QuantMap
arg_quantMap_ TypeSyns
arg_typeSyns_ UniqueMap
arg_uniqueMap_ UseMap
arg_useMap_ Set NontermIdent
arg_wrappers_
         _lhsOself :: Grammar
         _lhsOself :: Grammar
_lhsOself = forall a. a -> a
rule251 Grammar
_self
         _nontsOclosedHoNtDeps :: Map NontermIdent (Set NontermIdent)
_nontsOclosedHoNtDeps = forall a. a -> a
rule252 Map NontermIdent (Set NontermIdent)
_closedHoNtDeps
         _nontsOclosedHoNtRevDeps :: Map NontermIdent (Set NontermIdent)
_nontsOclosedHoNtRevDeps = forall a. a -> a
rule253 Map NontermIdent (Set NontermIdent)
_closedHoNtRevDeps
         _nontsOclosedNtDeps :: Map NontermIdent (Set NontermIdent)
_nontsOclosedNtDeps = forall a. a -> a
rule254 Map NontermIdent (Set NontermIdent)
_closedNtDeps
         _nontsOnmp :: NMP
_nontsOnmp = forall a. a -> a
rule255 NMP
_nmp
         _nontsOoptions :: Options
_nontsOoptions = Options -> Options
rule256 Options
_lhsIoptions
         __result_ :: T_Grammar_vOut49
__result_ = Maybe PP_Doc
-> Seq Error
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> ExecutionPlan
-> Grammar
-> Map NontermIdent (Map NontermIdent Type)
-> T_Grammar_vOut49
T_Grammar_vOut49 Maybe PP_Doc
_lhsOads Seq Error
_lhsOerrors Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap ExecutionPlan
_lhsOoutput Grammar
_lhsOself Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap
         in T_Grammar_vOut49
__result_ )
     in T_Grammar_v49 -> T_Grammar_s50
C_Grammar_s50 T_Grammar_v49
v49
   {-# INLINE rule205 #-}
   {-# LINE 40 "src-ag/ExecutionPlanCommon.ag" #-}
   rule205 = \ ((_nontsIntDeps) :: Map NontermIdent (Set NontermIdent)) ->
                            {-# LINE 40 "src-ag/ExecutionPlanCommon.ag" #-}
                            closeMap _nontsIntDeps
                            {-# LINE 2269 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule206 #-}
   {-# LINE 41 "src-ag/ExecutionPlanCommon.ag" #-}
   rule206 = \ ((_nontsIntHoDeps) :: Map NontermIdent (Set NontermIdent)) ->
                            {-# LINE 41 "src-ag/ExecutionPlanCommon.ag" #-}
                            closeMap _nontsIntHoDeps
                            {-# LINE 2275 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule207 #-}
   {-# LINE 42 "src-ag/ExecutionPlanCommon.ag" #-}
   rule207 = \ _closedHoNtDeps ->
                            {-# LINE 42 "src-ag/ExecutionPlanCommon.ag" #-}
                            revDeps _closedHoNtDeps
                            {-# LINE 2281 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule208 #-}
   {-# LINE 51 "src-ag/ExecutionPlanCommon.ag" #-}
   rule208 = \ contextMap_ ->
                          {-# LINE 51 "src-ag/ExecutionPlanCommon.ag" #-}
                          contextMap_
                          {-# LINE 2287 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule209 #-}
   {-# LINE 92 "src-ag/ExecutionPlanCommon.ag" #-}
   rule209 = \ aroundsMap_ ->
                      {-# LINE 92 "src-ag/ExecutionPlanCommon.ag" #-}
                      aroundsMap_
                      {-# LINE 2293 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule210 #-}
   {-# LINE 117 "src-ag/ExecutionPlanCommon.ag" #-}
   rule210 = \ mergeMap_ ->
                     {-# LINE 117 "src-ag/ExecutionPlanCommon.ag" #-}
                     mergeMap_
                     {-# LINE 2299 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule211 #-}
   {-# LINE 9 "src-ag/ExecutionPlanPre.ag" #-}
   rule211 = \  (_ :: ()) ->
                                  {-# LINE 9 "src-ag/ExecutionPlanPre.ag" #-}
                                  0
                                  {-# LINE 2305 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule212 #-}
   {-# LINE 38 "src-ag/LOAG/Prepare.ag" #-}
   rule212 = \ ((_nontsIpmp) :: PMP) ->
                 {-# LINE 38 "src-ag/LOAG/Prepare.ag" #-}
                 if Map.null _nontsIpmp then 1 else fst $ Map.findMin _nontsIpmp
                 {-# LINE 2311 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule213 #-}
   {-# LINE 40 "src-ag/LOAG/Prepare.ag" #-}
   rule213 = \ _ain _an _asn _initO _nmp _nmpr ((_nontsIap) :: A_P) ((_nontsIfieldMap) :: FMap) ((_nontsIfsInP) :: FsInP) ((_nontsIfty) :: FTY) ((_nontsIgen) :: Map Int Int) ((_nontsIinss) :: Map Int [Int]) ((_nontsIofld) :: [(Int, Int)]) ((_nontsIpmp) :: PMP) ((_nontsIpmpr) :: PMP_R) ((_nontsIps) :: [PLabel]) _sfp ->
          {-# LINE 40 "src-ag/LOAG/Prepare.ag" #-}
          LOAGRep _nontsIps _nontsIap _an
             _ain     _asn     _sfp
             _nontsIpmp _nontsIpmpr _nmp     _nmpr
             (A.array (_initO    , _initO     + Map.size _nontsIgen)  $
                  Map.toList $ _nontsIgen)
             (A.array (1,Map.size _nontsIinss) $
                  Map.toList $ _nontsIinss)
             (A.array (_initO    , _initO     + length _nontsIofld) $
                  _nontsIofld) _nontsIfty _nontsIfieldMap _nontsIfsInP
          {-# LINE 2325 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule214 #-}
   {-# LINE 49 "src-ag/LOAG/Prepare.ag" #-}
   rule214 = \ _atts ->
                 {-# LINE 49 "src-ag/LOAG/Prepare.ag" #-}
                 Map.fromList $ zip [1..] _atts
                 {-# LINE 2331 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule215 #-}
   {-# LINE 50 "src-ag/LOAG/Prepare.ag" #-}
   rule215 = \ _atts ->
                 {-# LINE 50 "src-ag/LOAG/Prepare.ag" #-}
                 Map.fromList $ zip _atts     [1..]
                 {-# LINE 2337 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule216 #-}
   {-# LINE 51 "src-ag/LOAG/Prepare.ag" #-}
   rule216 = \ _ain _asn ->
                 {-# LINE 51 "src-ag/LOAG/Prepare.ag" #-}
                 Map.unionWith (++) _ain     _asn
                 {-# LINE 2343 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule217 #-}
   {-# LINE 52 "src-ag/LOAG/Prepare.ag" #-}
   rule217 = \ ((_nontsIinhs) :: AI_N) ->
                 {-# LINE 52 "src-ag/LOAG/Prepare.ag" #-}
                 _nontsIinhs
                 {-# LINE 2349 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule218 #-}
   {-# LINE 53 "src-ag/LOAG/Prepare.ag" #-}
   rule218 = \ ((_nontsIsyns) :: AS_N) ->
                 {-# LINE 53 "src-ag/LOAG/Prepare.ag" #-}
                 _nontsIsyns
                 {-# LINE 2355 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule219 #-}
   {-# LINE 54 "src-ag/LOAG/Prepare.ag" #-}
   rule219 = \ _an ->
                 {-# LINE 54 "src-ag/LOAG/Prepare.ag" #-}
                 concat $ Map.elems _an
                 {-# LINE 2361 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule220 #-}
   {-# LINE 55 "src-ag/LOAG/Prepare.ag" #-}
   rule220 = \ ((_nontsIap) :: A_P) ->
                 {-# LINE 55 "src-ag/LOAG/Prepare.ag" #-}
                 concat $ Map.elems _nontsIap
                 {-# LINE 2367 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule221 #-}
   {-# LINE 56 "src-ag/LOAG/Prepare.ag" #-}
   rule221 = \ manualAttrOrderMap_ ->
                   {-# LINE 56 "src-ag/LOAG/Prepare.ag" #-}
                   manualAttrOrderMap_
                   {-# LINE 2373 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule222 #-}
   {-# LINE 87 "src-ag/LOAG/Prepare.ag" #-}
   rule222 = \ _ain ->
                   {-# LINE 87 "src-ag/LOAG/Prepare.ag" #-}
                   map2F _ain
                   {-# LINE 2379 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule223 #-}
   {-# LINE 88 "src-ag/LOAG/Prepare.ag" #-}
   rule223 = \ _asn ->
                   {-# LINE 88 "src-ag/LOAG/Prepare.ag" #-}
                   map2F _asn
                   {-# LINE 2385 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule224 #-}
   {-# LINE 89 "src-ag/LOAG/Prepare.ag" #-}
   rule224 = \ ((_nontsIpmp) :: PMP) ->
                    {-# LINE 89 "src-ag/LOAG/Prepare.ag" #-}
                    _nontsIpmp
                    {-# LINE 2391 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule225 #-}
   {-# LINE 90 "src-ag/LOAG/Prepare.ag" #-}
   rule225 = \ ((_nontsIpmpr) :: PMP_R) ->
                    {-# LINE 90 "src-ag/LOAG/Prepare.ag" #-}
                    _nontsIpmpr
                    {-# LINE 2397 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule226 #-}
   {-# LINE 91 "src-ag/LOAG/Prepare.ag" #-}
   rule226 = \ ((_nontsIlfp) :: SF_P) ->
                    {-# LINE 91 "src-ag/LOAG/Prepare.ag" #-}
                    _nontsIlfp
                    {-# LINE 2403 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule227 #-}
   {-# LINE 92 "src-ag/LOAG/Prepare.ag" #-}
   rule227 = \ ((_nontsIhoMap) :: HOMap) ->
                    {-# LINE 92 "src-ag/LOAG/Prepare.ag" #-}
                    _nontsIhoMap
                    {-# LINE 2409 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule228 #-}
   {-# LINE 93 "src-ag/LOAG/Prepare.ag" #-}
   rule228 = \ ((_nontsIfty) :: FTY) ->
                    {-# LINE 93 "src-ag/LOAG/Prepare.ag" #-}
                    _nontsIfty
                    {-# LINE 2415 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule229 #-}
   {-# LINE 94 "src-ag/LOAG/Prepare.ag" #-}
   rule229 = \ ((_nontsIfty) :: FTY) ->
                    {-# LINE 94 "src-ag/LOAG/Prepare.ag" #-}
                    _nontsIfty
                    {-# LINE 2421 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule230 #-}
   {-# LINE 103 "src-ag/LOAG/Prepare.ag" #-}
   rule230 = \ ((_nontsIps) :: [PLabel]) ->
                {-# LINE 103 "src-ag/LOAG/Prepare.ag" #-}
                _nontsIps
                {-# LINE 2427 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule231 #-}
   {-# LINE 150 "src-ag/LOAG/Prepare.ag" #-}
   rule231 = \ _an ->
                 {-# LINE 150 "src-ag/LOAG/Prepare.ag" #-}
                 map2F _an
                 {-# LINE 2433 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule232 #-}
   {-# LINE 151 "src-ag/LOAG/Prepare.ag" #-}
   rule232 = \ _nmpr ->
                   {-# LINE 151 "src-ag/LOAG/Prepare.ag" #-}
                   _nmpr
                   {-# LINE 2439 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule233 #-}
   {-# LINE 152 "src-ag/LOAG/Prepare.ag" #-}
   rule233 = \ _nmp ->
                   {-# LINE 152 "src-ag/LOAG/Prepare.ag" #-}
                   if Map.null _nmp     then 0 else (fst $ Map.findMax _nmp    )
                   {-# LINE 2445 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule234 #-}
   {-# LINE 153 "src-ag/LOAG/Prepare.ag" #-}
   rule234 = \  (_ :: ()) ->
                   {-# LINE 153 "src-ag/LOAG/Prepare.ag" #-}
                   0
                   {-# LINE 2451 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule235 #-}
   {-# LINE 207 "src-ag/LOAG/Prepare.ag" #-}
   rule235 = \ ((_nontsIlfp) :: SF_P) ((_nontsIsfp) :: SF_P) ->
                 {-# LINE 207 "src-ag/LOAG/Prepare.ag" #-}
                 repLocRefs _nontsIlfp $ addHigherOrders _nontsIlfp _nontsIsfp
                 {-# LINE 2457 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule236 #-}
   {-# LINE 54 "src-ag/LOAG/Order.ag" #-}
   rule236 = \ _schedRes ->
                   {-# LINE 54 "src-ag/LOAG/Order.ag" #-}
                   either Seq.singleton (const Seq.empty) _schedRes
                   {-# LINE 2463 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule237 #-}
   {-# LINE 55 "src-ag/LOAG/Order.ag" #-}
   rule237 = \ ((_lhsIoptions) :: Options) ((_nontsIpmp) :: PMP) _schedRes ->
                   {-# LINE 55 "src-ag/LOAG/Order.ag" #-}
                   case either (const []) trd' _schedRes     of
                      []  -> Nothing
                      ads -> Just $ ppAds _lhsIoptions _nontsIpmp ads
                   {-# LINE 2471 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule238 #-}
   {-# LINE 58 "src-ag/LOAG/Order.ag" #-}
   rule238 = \ ((_nontsIenonts) :: ENonterminals) derivings_ typeSyns_ wrappers_ ->
                   {-# LINE 58 "src-ag/LOAG/Order.ag" #-}
                   ExecutionPlan _nontsIenonts typeSyns_ wrappers_ derivings_
                   {-# LINE 2477 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule239 #-}
   {-# LINE 60 "src-ag/LOAG/Order.ag" #-}
   rule239 = \ _schedRes ->
                      {-# LINE 60 "src-ag/LOAG/Order.ag" #-}
                      either (const Map.empty) snd' _schedRes
                      {-# LINE 2483 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule240 #-}
   {-# LINE 61 "src-ag/LOAG/Order.ag" #-}
   rule240 = \ _schedRes ->
                      {-# LINE 61 "src-ag/LOAG/Order.ag" #-}
                      either (error "no tdp") (fromJust.fst') _schedRes
                      {-# LINE 2489 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule241 #-}
   {-# LINE 63 "src-ag/LOAG/Order.ag" #-}
   rule241 = \ _ag ((_lhsIoptions) :: Options) _loagRes ((_nontsIads) :: [Edge]) _self ((_smfIself) :: LOAGRep) ->
                       {-# LINE 63 "src-ag/LOAG/Order.ag" #-}
                       if CT.loag _lhsIoptions
                          then if CT.aoag _lhsIoptions
                                  then AOAG.schedule _smfIself _self _ag     _nontsIads
                                  else _loagRes
                          else Right (Nothing,Map.empty,[])
                       {-# LINE 2499 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule242 #-}
   {-# LINE 68 "src-ag/LOAG/Order.ag" #-}
   rule242 = \ _ag ((_lhsIoptions) :: Options) ->
                    {-# LINE 68 "src-ag/LOAG/Order.ag" #-}
                    let putStrLn s = when (verbose _lhsIoptions) (IO.putStrLn s)
                    in  Right $ unsafePerformIO $ scheduleLOAG _ag     putStrLn _lhsIoptions
                    {-# LINE 2506 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule243 #-}
   {-# LINE 70 "src-ag/LOAG/Order.ag" #-}
   rule243 = \ _self ((_smfIself) :: LOAGRep) ->
               {-# LINE 70 "src-ag/LOAG/Order.ag" #-}
               repToAg _smfIself _self
               {-# LINE 2512 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule244 #-}
   {-# LINE 72 "src-ag/LOAG/Order.ag" #-}
   rule244 = \ _schedRes ->
                      {-# LINE 72 "src-ag/LOAG/Order.ag" #-}
                      either (const []) trd' _schedRes
                      {-# LINE 2518 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule245 #-}
   {-# LINE 133 "src-ag/LOAG/Order.ag" #-}
   rule245 = \ ((_nontsIvisMap) :: IMap.IntMap Int) ->
                              {-# LINE 133 "src-ag/LOAG/Order.ag" #-}
                              _nontsIvisMap
                              {-# LINE 2524 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule246 #-}
   {-# LINE 134 "src-ag/LOAG/Order.ag" #-}
   rule246 = \  (_ :: ()) ->
                               {-# LINE 134 "src-ag/LOAG/Order.ag" #-}
                               0
                               {-# LINE 2530 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule247 #-}
   rule247 = \ ((_nontsIinhmap) :: Map.Map NontermIdent Attributes) ->
     _nontsIinhmap
   {-# INLINE rule248 #-}
   rule248 = \ ((_nontsIlocalSigMap) :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))) ->
     _nontsIlocalSigMap
   {-# INLINE rule249 #-}
   rule249 = \ ((_nontsIsynmap) :: Map.Map NontermIdent Attributes) ->
     _nontsIsynmap
   {-# INLINE rule250 #-}
   rule250 = \ ((_nontsIself) :: Nonterminals) aroundsMap_ augmentsMap_ contextMap_ derivings_ manualAttrOrderMap_ mergeMap_ paramMap_ pragmas_ quantMap_ typeSyns_ uniqueMap_ useMap_ wrappers_ ->
     Grammar typeSyns_ useMap_ derivings_ wrappers_ _nontsIself pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ quantMap_ uniqueMap_ augmentsMap_ aroundsMap_ mergeMap_
   {-# INLINE rule251 #-}
   rule251 = \ _self ->
     _self
   {-# INLINE rule252 #-}
   rule252 = \ _closedHoNtDeps ->
     _closedHoNtDeps
   {-# INLINE rule253 #-}
   rule253 = \ _closedHoNtRevDeps ->
     _closedHoNtRevDeps
   {-# INLINE rule254 #-}
   rule254 = \ _closedNtDeps ->
     _closedNtDeps
   {-# INLINE rule255 #-}
   rule255 = \ _nmp ->
     _nmp
   {-# INLINE rule256 #-}
   rule256 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions

-- HsToken -----------------------------------------------------
-- wrapper
data Inh_HsToken  = Inh_HsToken { Inh_HsToken -> PLabel
pll_Inh_HsToken :: (PLabel), Inh_HsToken -> Set FLabel
pts_Inh_HsToken :: (Set.Set (FLabel)) }
data Syn_HsToken  = Syn_HsToken { Syn_HsToken -> HsToken
self_Syn_HsToken :: (HsToken), Syn_HsToken -> Set MyOccurrence
used_Syn_HsToken :: (Set.Set MyOccurrence) }
{-# INLINABLE wrap_HsToken #-}
wrap_HsToken :: T_HsToken  -> Inh_HsToken  -> (Syn_HsToken )
wrap_HsToken :: T_HsToken -> Inh_HsToken -> Syn_HsToken
wrap_HsToken (T_HsToken Identity T_HsToken_s53
act) (Inh_HsToken PLabel
_lhsIpll Set FLabel
_lhsIpts) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_HsToken_s53
sem <- Identity T_HsToken_s53
act
        let arg52 :: T_HsToken_vIn52
arg52 = PLabel -> Set FLabel -> T_HsToken_vIn52
T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts
        (T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsToken_s53 -> T_HsToken_v52
inv_HsToken_s53 T_HsToken_s53
sem T_HsToken_vIn52
arg52)
        forall (m :: * -> *) a. Monad m => a -> m a
return (HsToken -> Set MyOccurrence -> Syn_HsToken
Syn_HsToken HsToken
_lhsOself Set MyOccurrence
_lhsOused)
   )

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

-- semantic domain
newtype T_HsToken  = T_HsToken {
                               T_HsToken -> Identity T_HsToken_s53
attach_T_HsToken :: Identity (T_HsToken_s53 )
                               }
newtype T_HsToken_s53  = C_HsToken_s53 {
                                       T_HsToken_s53 -> T_HsToken_v52
inv_HsToken_s53 :: (T_HsToken_v52 )
                                       }
data T_HsToken_s54  = C_HsToken_s54
type T_HsToken_v52  = (T_HsToken_vIn52 ) -> (T_HsToken_vOut52 )
data T_HsToken_vIn52  = T_HsToken_vIn52 (PLabel) (Set.Set (FLabel))
data T_HsToken_vOut52  = T_HsToken_vOut52 (HsToken) (Set.Set MyOccurrence)
{-# NOINLINE sem_HsToken_AGLocal #-}
sem_HsToken_AGLocal :: (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGLocal :: NontermIdent -> Pos -> Maybe FLabel -> T_HsToken
sem_HsToken_AGLocal NontermIdent
arg_var_ Pos
arg_pos_ Maybe FLabel
arg_rdesc_ = Identity T_HsToken_s53 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s53
st53) where
   {-# NOINLINE st53 #-}
   st53 :: T_HsToken_s53
st53 = let
      v52 :: T_HsToken_v52 
      v52 :: T_HsToken_v52
v52 = \ (T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = PLabel -> Set FLabel -> NontermIdent -> Set MyOccurrence
rule257 PLabel
_lhsIpll Set FLabel
_lhsIpts NontermIdent
arg_var_
         _self :: HsToken
_self = Pos -> Maybe FLabel -> NontermIdent -> HsToken
rule258 Pos
arg_pos_ Maybe FLabel
arg_rdesc_ NontermIdent
arg_var_
         _lhsOself :: HsToken
         _lhsOself :: HsToken
_lhsOself = forall a. a -> a
rule259 HsToken
_self
         __result_ :: T_HsToken_vOut52
__result_ = HsToken -> Set MyOccurrence -> T_HsToken_vOut52
T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsToken_vOut52
__result_ )
     in T_HsToken_v52 -> T_HsToken_s53
C_HsToken_s53 T_HsToken_v52
v52
   {-# INLINE rule257 #-}
   {-# LINE 281 "src-ag/LOAG/Prepare.ag" #-}
   rule257 = \ ((_lhsIpll) :: PLabel) ((_lhsIpts) :: Set.Set (FLabel)) var_ ->
          {-# LINE 281 "src-ag/LOAG/Prepare.ag" #-}
          case getName var_ `Set.member` _lhsIpts of
            True  -> Set.empty
            False -> Set.singleton $ (_lhsIpll, getName _LOC) >.<
                          (getName var_, drhs _LOC)
          {-# LINE 2620 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule258 #-}
   rule258 = \ pos_ rdesc_ var_ ->
     AGLocal var_ pos_ rdesc_
   {-# INLINE rule259 #-}
   rule259 = \ _self ->
     _self
{-# NOINLINE sem_HsToken_AGField #-}
sem_HsToken_AGField :: (Identifier) -> (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGField :: NontermIdent -> NontermIdent -> Pos -> Maybe FLabel -> T_HsToken
sem_HsToken_AGField NontermIdent
arg_field_ NontermIdent
arg_attr_ Pos
arg_pos_ Maybe FLabel
arg_rdesc_ = Identity T_HsToken_s53 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s53
st53) where
   {-# NOINLINE st53 #-}
   st53 :: T_HsToken_s53
st53 = let
      v52 :: T_HsToken_v52 
      v52 :: T_HsToken_v52
v52 = \ (T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = PLabel -> NontermIdent -> NontermIdent -> Set MyOccurrence
rule260 PLabel
_lhsIpll NontermIdent
arg_attr_ NontermIdent
arg_field_
         _self :: HsToken
_self = NontermIdent -> NontermIdent -> Pos -> Maybe FLabel -> HsToken
rule261 NontermIdent
arg_attr_ NontermIdent
arg_field_ Pos
arg_pos_ Maybe FLabel
arg_rdesc_
         _lhsOself :: HsToken
         _lhsOself :: HsToken
_lhsOself = forall a. a -> a
rule262 HsToken
_self
         __result_ :: T_HsToken_vOut52
__result_ = HsToken -> Set MyOccurrence -> T_HsToken_vOut52
T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsToken_vOut52
__result_ )
     in T_HsToken_v52 -> T_HsToken_s53
C_HsToken_s53 T_HsToken_v52
v52
   {-# INLINE rule260 #-}
   {-# LINE 289 "src-ag/LOAG/Prepare.ag" #-}
   rule260 = \ ((_lhsIpll) :: PLabel) attr_ field_ ->
                 {-# LINE 289 "src-ag/LOAG/Prepare.ag" #-}
                 Set.singleton $ (_lhsIpll, getName field_) >.<
                                  (getName attr_, drhs field_)
                 {-# LINE 2648 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule261 #-}
   rule261 = \ attr_ field_ pos_ rdesc_ ->
     AGField field_ attr_ pos_ rdesc_
   {-# INLINE rule262 #-}
   rule262 = \ _self ->
     _self
{-# NOINLINE sem_HsToken_HsToken #-}
sem_HsToken_HsToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_HsToken :: FLabel -> Pos -> T_HsToken
sem_HsToken_HsToken FLabel
arg_value_ Pos
arg_pos_ = Identity T_HsToken_s53 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s53
st53) where
   {-# NOINLINE st53 #-}
   st53 :: T_HsToken_s53
st53 = let
      v52 :: T_HsToken_v52 
      v52 :: T_HsToken_v52
v52 = \ (T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = forall {a}. () -> Set a
rule263  ()
         _self :: HsToken
_self = Pos -> FLabel -> HsToken
rule264 Pos
arg_pos_ FLabel
arg_value_
         _lhsOself :: HsToken
         _lhsOself :: HsToken
_lhsOself = forall a. a -> a
rule265 HsToken
_self
         __result_ :: T_HsToken_vOut52
__result_ = HsToken -> Set MyOccurrence -> T_HsToken_vOut52
T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsToken_vOut52
__result_ )
     in T_HsToken_v52 -> T_HsToken_s53
C_HsToken_s53 T_HsToken_v52
v52
   {-# INLINE rule263 #-}
   rule263 :: () -> Set a
rule263 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# INLINE rule264 #-}
   rule264 :: Pos -> FLabel -> HsToken
rule264 = \ Pos
pos_ FLabel
value_ ->
     FLabel -> Pos -> HsToken
HsToken FLabel
value_ Pos
pos_
   {-# INLINE rule265 #-}
   rule265 :: p -> p
rule265 = \ p
_self ->
     p
_self
{-# NOINLINE sem_HsToken_CharToken #-}
sem_HsToken_CharToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_CharToken :: FLabel -> Pos -> T_HsToken
sem_HsToken_CharToken FLabel
arg_value_ Pos
arg_pos_ = Identity T_HsToken_s53 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s53
st53) where
   {-# NOINLINE st53 #-}
   st53 :: T_HsToken_s53
st53 = let
      v52 :: T_HsToken_v52 
      v52 :: T_HsToken_v52
v52 = \ (T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = forall {a}. () -> Set a
rule266  ()
         _self :: HsToken
_self = Pos -> FLabel -> HsToken
rule267 Pos
arg_pos_ FLabel
arg_value_
         _lhsOself :: HsToken
         _lhsOself :: HsToken
_lhsOself = forall a. a -> a
rule268 HsToken
_self
         __result_ :: T_HsToken_vOut52
__result_ = HsToken -> Set MyOccurrence -> T_HsToken_vOut52
T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsToken_vOut52
__result_ )
     in T_HsToken_v52 -> T_HsToken_s53
C_HsToken_s53 T_HsToken_v52
v52
   {-# INLINE rule266 #-}
   rule266 :: () -> Set a
rule266 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# INLINE rule267 #-}
   rule267 :: Pos -> FLabel -> HsToken
rule267 = \ Pos
pos_ FLabel
value_ ->
     FLabel -> Pos -> HsToken
CharToken FLabel
value_ Pos
pos_
   {-# INLINE rule268 #-}
   rule268 :: p -> p
rule268 = \ p
_self ->
     p
_self
{-# NOINLINE sem_HsToken_StrToken #-}
sem_HsToken_StrToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_StrToken :: FLabel -> Pos -> T_HsToken
sem_HsToken_StrToken FLabel
arg_value_ Pos
arg_pos_ = Identity T_HsToken_s53 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s53
st53) where
   {-# NOINLINE st53 #-}
   st53 :: T_HsToken_s53
st53 = let
      v52 :: T_HsToken_v52 
      v52 :: T_HsToken_v52
v52 = \ (T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = forall {a}. () -> Set a
rule269  ()
         _self :: HsToken
_self = Pos -> FLabel -> HsToken
rule270 Pos
arg_pos_ FLabel
arg_value_
         _lhsOself :: HsToken
         _lhsOself :: HsToken
_lhsOself = forall a. a -> a
rule271 HsToken
_self
         __result_ :: T_HsToken_vOut52
__result_ = HsToken -> Set MyOccurrence -> T_HsToken_vOut52
T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsToken_vOut52
__result_ )
     in T_HsToken_v52 -> T_HsToken_s53
C_HsToken_s53 T_HsToken_v52
v52
   {-# INLINE rule269 #-}
   rule269 :: () -> Set a
rule269 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# INLINE rule270 #-}
   rule270 :: Pos -> FLabel -> HsToken
rule270 = \ Pos
pos_ FLabel
value_ ->
     FLabel -> Pos -> HsToken
StrToken FLabel
value_ Pos
pos_
   {-# INLINE rule271 #-}
   rule271 :: p -> p
rule271 = \ p
_self ->
     p
_self
{-# NOINLINE sem_HsToken_Err #-}
sem_HsToken_Err :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_Err :: FLabel -> Pos -> T_HsToken
sem_HsToken_Err FLabel
arg_mesg_ Pos
arg_pos_ = Identity T_HsToken_s53 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s53
st53) where
   {-# NOINLINE st53 #-}
   st53 :: T_HsToken_s53
st53 = let
      v52 :: T_HsToken_v52 
      v52 :: T_HsToken_v52
v52 = \ (T_HsToken_vIn52 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = forall {a}. () -> Set a
rule272  ()
         _self :: HsToken
_self = FLabel -> Pos -> HsToken
rule273 FLabel
arg_mesg_ Pos
arg_pos_
         _lhsOself :: HsToken
         _lhsOself :: HsToken
_lhsOself = forall a. a -> a
rule274 HsToken
_self
         __result_ :: T_HsToken_vOut52
__result_ = HsToken -> Set MyOccurrence -> T_HsToken_vOut52
T_HsToken_vOut52 HsToken
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsToken_vOut52
__result_ )
     in T_HsToken_v52 -> T_HsToken_s53
C_HsToken_s53 T_HsToken_v52
v52
   {-# INLINE rule272 #-}
   rule272 :: () -> Set a
rule272 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# INLINE rule273 #-}
   rule273 :: FLabel -> Pos -> HsToken
rule273 = \ FLabel
mesg_ Pos
pos_ ->
     FLabel -> Pos -> HsToken
Err FLabel
mesg_ Pos
pos_
   {-# INLINE rule274 #-}
   rule274 :: p -> p
rule274 = \ p
_self ->
     p
_self

-- HsTokens ----------------------------------------------------
-- wrapper
data Inh_HsTokens  = Inh_HsTokens { Inh_HsTokens -> PLabel
pll_Inh_HsTokens :: (PLabel), Inh_HsTokens -> Set FLabel
pts_Inh_HsTokens :: (Set.Set (FLabel)) }
data Syn_HsTokens  = Syn_HsTokens { Syn_HsTokens -> HsTokens
self_Syn_HsTokens :: (HsTokens), Syn_HsTokens -> Set MyOccurrence
used_Syn_HsTokens :: (Set.Set MyOccurrence) }
{-# INLINABLE wrap_HsTokens #-}
wrap_HsTokens :: T_HsTokens  -> Inh_HsTokens  -> (Syn_HsTokens )
wrap_HsTokens :: T_HsTokens -> Inh_HsTokens -> Syn_HsTokens
wrap_HsTokens (T_HsTokens Identity T_HsTokens_s56
act) (Inh_HsTokens PLabel
_lhsIpll Set FLabel
_lhsIpts) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_HsTokens_s56
sem <- Identity T_HsTokens_s56
act
        let arg55 :: T_HsTokens_vIn55
arg55 = PLabel -> Set FLabel -> T_HsTokens_vIn55
T_HsTokens_vIn55 PLabel
_lhsIpll Set FLabel
_lhsIpts
        (T_HsTokens_vOut55 HsTokens
_lhsOself Set MyOccurrence
_lhsOused) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokens_s56 -> T_HsTokens_v55
inv_HsTokens_s56 T_HsTokens_s56
sem T_HsTokens_vIn55
arg55)
        forall (m :: * -> *) a. Monad m => a -> m a
return (HsTokens -> Set MyOccurrence -> Syn_HsTokens
Syn_HsTokens HsTokens
_lhsOself Set MyOccurrence
_lhsOused)
   )

-- cata
{-# NOINLINE sem_HsTokens #-}
sem_HsTokens :: HsTokens  -> T_HsTokens 
sem_HsTokens :: HsTokens -> T_HsTokens
sem_HsTokens HsTokens
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsTokens
sem_HsTokens_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map HsToken -> T_HsToken
sem_HsToken HsTokens
list)

-- semantic domain
newtype T_HsTokens  = T_HsTokens {
                                 T_HsTokens -> Identity T_HsTokens_s56
attach_T_HsTokens :: Identity (T_HsTokens_s56 )
                                 }
newtype T_HsTokens_s56  = C_HsTokens_s56 {
                                         T_HsTokens_s56 -> T_HsTokens_v55
inv_HsTokens_s56 :: (T_HsTokens_v55 )
                                         }
data T_HsTokens_s57  = C_HsTokens_s57
type T_HsTokens_v55  = (T_HsTokens_vIn55 ) -> (T_HsTokens_vOut55 )
data T_HsTokens_vIn55  = T_HsTokens_vIn55 (PLabel) (Set.Set (FLabel))
data T_HsTokens_vOut55  = T_HsTokens_vOut55 (HsTokens) (Set.Set MyOccurrence)
{-# NOINLINE sem_HsTokens_Cons #-}
sem_HsTokens_Cons :: T_HsToken  -> T_HsTokens  -> T_HsTokens 
sem_HsTokens_Cons :: T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsToken
arg_hd_ T_HsTokens
arg_tl_ = Identity T_HsTokens_s56 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s56
st56) where
   {-# NOINLINE st56 #-}
   st56 :: T_HsTokens_s56
st56 = let
      v55 :: T_HsTokens_v55 
      v55 :: T_HsTokens_v55
v55 = \ (T_HsTokens_vIn55 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _hdX53 :: T_HsToken_s53
_hdX53 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsToken -> Identity T_HsToken_s53
attach_T_HsToken (T_HsToken
arg_hd_))
         _tlX56 :: T_HsTokens_s56
_tlX56 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s56
attach_T_HsTokens (T_HsTokens
arg_tl_))
         (T_HsToken_vOut52 HsToken
_hdIself Set MyOccurrence
_hdIused) = T_HsToken_s53 -> T_HsToken_v52
inv_HsToken_s53 T_HsToken_s53
_hdX53 (PLabel -> Set FLabel -> T_HsToken_vIn52
T_HsToken_vIn52 PLabel
_hdOpll Set FLabel
_hdOpts)
         (T_HsTokens_vOut55 HsTokens
_tlIself Set MyOccurrence
_tlIused) = T_HsTokens_s56 -> T_HsTokens_v55
inv_HsTokens_s56 T_HsTokens_s56
_tlX56 (PLabel -> Set FLabel -> T_HsTokens_vIn55
T_HsTokens_vIn55 PLabel
_tlOpll Set FLabel
_tlOpts)
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = Set MyOccurrence -> Set MyOccurrence -> Set MyOccurrence
rule275 Set MyOccurrence
_hdIused Set MyOccurrence
_tlIused
         _self :: HsTokens
_self = HsToken -> HsTokens -> HsTokens
rule276 HsToken
_hdIself HsTokens
_tlIself
         _lhsOself :: HsTokens
         _lhsOself :: HsTokens
_lhsOself = forall a. a -> a
rule277 HsTokens
_self
         _hdOpll :: PLabel
_hdOpll = PLabel -> PLabel
rule278 PLabel
_lhsIpll
         _hdOpts :: Set FLabel
_hdOpts = Set FLabel -> Set FLabel
rule279 Set FLabel
_lhsIpts
         _tlOpll :: PLabel
_tlOpll = PLabel -> PLabel
rule280 PLabel
_lhsIpll
         _tlOpts :: Set FLabel
_tlOpts = Set FLabel -> Set FLabel
rule281 Set FLabel
_lhsIpts
         __result_ :: T_HsTokens_vOut55
__result_ = HsTokens -> Set MyOccurrence -> T_HsTokens_vOut55
T_HsTokens_vOut55 HsTokens
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsTokens_vOut55
__result_ )
     in T_HsTokens_v55 -> T_HsTokens_s56
C_HsTokens_s56 T_HsTokens_v55
v55
   {-# INLINE rule275 #-}
   rule275 :: Set MyOccurrence -> Set MyOccurrence -> Set MyOccurrence
rule275 = \ ((Set MyOccurrence
_hdIused) :: Set.Set MyOccurrence) ((Set MyOccurrence
_tlIused) :: Set.Set MyOccurrence) ->
     (forall a. Ord a => Set a -> Set a -> Set a
Set.union Set MyOccurrence
_hdIused Set MyOccurrence
_tlIused)
   {-# INLINE rule276 #-}
   rule276 :: HsToken -> HsTokens -> HsTokens
rule276 = \ ((HsToken
_hdIself) :: HsToken) ((HsTokens
_tlIself) :: HsTokens) ->
     (:) HsToken
_hdIself HsTokens
_tlIself
   {-# INLINE rule277 #-}
   rule277 :: p -> p
rule277 = \ p
_self ->
     p
_self
   {-# INLINE rule278 #-}
   rule278 :: PLabel -> PLabel
rule278 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule279 #-}
   rule279 :: Set FLabel -> Set FLabel
rule279 = \ ((Set FLabel
_lhsIpts) :: Set.Set (FLabel)) ->
     Set FLabel
_lhsIpts
   {-# INLINE rule280 #-}
   rule280 :: PLabel -> PLabel
rule280 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule281 #-}
   rule281 :: Set FLabel -> Set FLabel
rule281 = \ ((Set FLabel
_lhsIpts) :: Set.Set (FLabel)) ->
     Set FLabel
_lhsIpts
{-# NOINLINE sem_HsTokens_Nil #-}
sem_HsTokens_Nil ::  T_HsTokens 
sem_HsTokens_Nil :: T_HsTokens
sem_HsTokens_Nil  = Identity T_HsTokens_s56 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s56
st56) where
   {-# NOINLINE st56 #-}
   st56 :: T_HsTokens_s56
st56 = let
      v55 :: T_HsTokens_v55 
      v55 :: T_HsTokens_v55
v55 = \ (T_HsTokens_vIn55 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = forall {a}. () -> Set a
rule282  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule283  ()
         _lhsOself :: HsTokens
         _lhsOself :: HsTokens
_lhsOself = forall a. a -> a
rule284 forall a. [a]
_self
         __result_ :: T_HsTokens_vOut55
__result_ = HsTokens -> Set MyOccurrence -> T_HsTokens_vOut55
T_HsTokens_vOut55 HsTokens
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsTokens_vOut55
__result_ )
     in T_HsTokens_v55 -> T_HsTokens_s56
C_HsTokens_s56 T_HsTokens_v55
v55
   {-# INLINE rule282 #-}
   rule282 :: () -> Set a
rule282 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# INLINE rule283 #-}
   rule283 :: () -> [a]
rule283 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule284 #-}
   rule284 :: p -> p
rule284 = \ p
_self ->
     p
_self

-- HsTokensRoot ------------------------------------------------
-- wrapper
data Inh_HsTokensRoot  = Inh_HsTokensRoot { Inh_HsTokensRoot -> PLabel
pll_Inh_HsTokensRoot :: (PLabel), Inh_HsTokensRoot -> Set FLabel
pts_Inh_HsTokensRoot :: (Set.Set (FLabel)) }
data Syn_HsTokensRoot  = Syn_HsTokensRoot { Syn_HsTokensRoot -> HsTokensRoot
self_Syn_HsTokensRoot :: (HsTokensRoot), Syn_HsTokensRoot -> Set MyOccurrence
used_Syn_HsTokensRoot :: (Set.Set MyOccurrence) }
{-# INLINABLE wrap_HsTokensRoot #-}
wrap_HsTokensRoot :: T_HsTokensRoot  -> Inh_HsTokensRoot  -> (Syn_HsTokensRoot )
wrap_HsTokensRoot :: T_HsTokensRoot -> Inh_HsTokensRoot -> Syn_HsTokensRoot
wrap_HsTokensRoot (T_HsTokensRoot Identity T_HsTokensRoot_s59
act) (Inh_HsTokensRoot PLabel
_lhsIpll Set FLabel
_lhsIpts) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_HsTokensRoot_s59
sem <- Identity T_HsTokensRoot_s59
act
        let arg58 :: T_HsTokensRoot_vIn58
arg58 = PLabel -> Set FLabel -> T_HsTokensRoot_vIn58
T_HsTokensRoot_vIn58 PLabel
_lhsIpll Set FLabel
_lhsIpts
        (T_HsTokensRoot_vOut58 HsTokensRoot
_lhsOself Set MyOccurrence
_lhsOused) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokensRoot_s59 -> T_HsTokensRoot_v58
inv_HsTokensRoot_s59 T_HsTokensRoot_s59
sem T_HsTokensRoot_vIn58
arg58)
        forall (m :: * -> *) a. Monad m => a -> m a
return (HsTokensRoot -> Set MyOccurrence -> Syn_HsTokensRoot
Syn_HsTokensRoot HsTokensRoot
_lhsOself Set MyOccurrence
_lhsOused)
   )

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

-- semantic domain
newtype T_HsTokensRoot  = T_HsTokensRoot {
                                         T_HsTokensRoot -> Identity T_HsTokensRoot_s59
attach_T_HsTokensRoot :: Identity (T_HsTokensRoot_s59 )
                                         }
newtype T_HsTokensRoot_s59  = C_HsTokensRoot_s59 {
                                                 T_HsTokensRoot_s59 -> T_HsTokensRoot_v58
inv_HsTokensRoot_s59 :: (T_HsTokensRoot_v58 )
                                                 }
data T_HsTokensRoot_s60  = C_HsTokensRoot_s60
type T_HsTokensRoot_v58  = (T_HsTokensRoot_vIn58 ) -> (T_HsTokensRoot_vOut58 )
data T_HsTokensRoot_vIn58  = T_HsTokensRoot_vIn58 (PLabel) (Set.Set (FLabel))
data T_HsTokensRoot_vOut58  = T_HsTokensRoot_vOut58 (HsTokensRoot) (Set.Set MyOccurrence)
{-# NOINLINE sem_HsTokensRoot_HsTokensRoot #-}
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens  -> T_HsTokensRoot 
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot T_HsTokens
arg_tokens_ = Identity T_HsTokensRoot_s59 -> T_HsTokensRoot
T_HsTokensRoot (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokensRoot_s59
st59) where
   {-# NOINLINE st59 #-}
   st59 :: T_HsTokensRoot_s59
st59 = let
      v58 :: T_HsTokensRoot_v58 
      v58 :: T_HsTokensRoot_v58
v58 = \ (T_HsTokensRoot_vIn58 PLabel
_lhsIpll Set FLabel
_lhsIpts) -> ( let
         _tokensX56 :: T_HsTokens_s56
_tokensX56 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s56
attach_T_HsTokens (T_HsTokens
arg_tokens_))
         (T_HsTokens_vOut55 HsTokens
_tokensIself Set MyOccurrence
_tokensIused) = T_HsTokens_s56 -> T_HsTokens_v55
inv_HsTokens_s56 T_HsTokens_s56
_tokensX56 (PLabel -> Set FLabel -> T_HsTokens_vIn55
T_HsTokens_vIn55 PLabel
_tokensOpll Set FLabel
_tokensOpts)
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = Set MyOccurrence -> Set MyOccurrence
rule285 Set MyOccurrence
_tokensIused
         _self :: HsTokensRoot
_self = HsTokens -> HsTokensRoot
rule286 HsTokens
_tokensIself
         _lhsOself :: HsTokensRoot
         _lhsOself :: HsTokensRoot
_lhsOself = forall a. a -> a
rule287 HsTokensRoot
_self
         _tokensOpll :: PLabel
_tokensOpll = PLabel -> PLabel
rule288 PLabel
_lhsIpll
         _tokensOpts :: Set FLabel
_tokensOpts = Set FLabel -> Set FLabel
rule289 Set FLabel
_lhsIpts
         __result_ :: T_HsTokensRoot_vOut58
__result_ = HsTokensRoot -> Set MyOccurrence -> T_HsTokensRoot_vOut58
T_HsTokensRoot_vOut58 HsTokensRoot
_lhsOself Set MyOccurrence
_lhsOused
         in T_HsTokensRoot_vOut58
__result_ )
     in T_HsTokensRoot_v58 -> T_HsTokensRoot_s59
C_HsTokensRoot_s59 T_HsTokensRoot_v58
v58
   {-# INLINE rule285 #-}
   rule285 :: Set MyOccurrence -> Set MyOccurrence
rule285 = \ ((Set MyOccurrence
_tokensIused) :: Set.Set MyOccurrence) ->
     Set MyOccurrence
_tokensIused
   {-# INLINE rule286 #-}
   rule286 :: HsTokens -> HsTokensRoot
rule286 = \ ((HsTokens
_tokensIself) :: HsTokens) ->
     HsTokens -> HsTokensRoot
HsTokensRoot HsTokens
_tokensIself
   {-# INLINE rule287 #-}
   rule287 :: p -> p
rule287 = \ p
_self ->
     p
_self
   {-# INLINE rule288 #-}
   rule288 :: PLabel -> PLabel
rule288 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule289 #-}
   rule289 :: Set FLabel -> Set FLabel
rule289 = \ ((Set FLabel
_lhsIpts) :: Set.Set (FLabel)) ->
     Set FLabel
_lhsIpts

-- LOAGRep -----------------------------------------------------
-- wrapper
data Inh_LOAGRep  = Inh_LOAGRep {  }
data Syn_LOAGRep  = Syn_LOAGRep { Syn_LOAGRep -> LOAGRep
self_Syn_LOAGRep :: (LOAGRep) }
{-# INLINABLE wrap_LOAGRep #-}
wrap_LOAGRep :: T_LOAGRep  -> Inh_LOAGRep  -> (Syn_LOAGRep )
wrap_LOAGRep :: T_LOAGRep -> Inh_LOAGRep -> Syn_LOAGRep
wrap_LOAGRep (T_LOAGRep Identity T_LOAGRep_s62
act) (Inh_LOAGRep
Inh_LOAGRep ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_LOAGRep_s62
sem <- Identity T_LOAGRep_s62
act
        let arg61 :: T_LOAGRep_vIn61
arg61 = T_LOAGRep_vIn61
T_LOAGRep_vIn61 
        (T_LOAGRep_vOut61 LOAGRep
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_LOAGRep_s62 -> T_LOAGRep_v61
inv_LOAGRep_s62 T_LOAGRep_s62
sem T_LOAGRep_vIn61
arg61)
        forall (m :: * -> *) a. Monad m => a -> m a
return (LOAGRep -> Syn_LOAGRep
Syn_LOAGRep LOAGRep
_lhsOself)
   )

-- cata
{-# INLINE sem_LOAGRep #-}
sem_LOAGRep :: LOAGRep  -> T_LOAGRep 
sem_LOAGRep :: LOAGRep -> T_LOAGRep
sem_LOAGRep ( LOAGRep [PLabel]
ps_ A_P
ap_ AI_N
an_ AI_N
ain_ AI_N
asn_ SF_P
sfp_ PMP
pmp_ PMP_R
pmpr_ NMP
nmp_ NMP_R
nmpr_ Array Int Int
gen_ Array Int [Int]
inss_ Array Int Int
ofld_ FTY
fty_ FMap
fieldMap_ Map PLabel [(PLabel, FLabel)]
fsInP_ ) = [PLabel]
-> A_P
-> AI_N
-> AI_N
-> AI_N
-> SF_P
-> PMP
-> PMP_R
-> NMP
-> NMP_R
-> Array Int Int
-> Array Int [Int]
-> Array Int Int
-> FTY
-> FMap
-> Map PLabel [(PLabel, FLabel)]
-> T_LOAGRep
sem_LOAGRep_LOAGRep [PLabel]
ps_ A_P
ap_ AI_N
an_ AI_N
ain_ AI_N
asn_ SF_P
sfp_ PMP
pmp_ PMP_R
pmpr_ NMP
nmp_ NMP_R
nmpr_ Array Int Int
gen_ Array Int [Int]
inss_ Array Int Int
ofld_ FTY
fty_ FMap
fieldMap_ Map PLabel [(PLabel, FLabel)]
fsInP_

-- semantic domain
newtype T_LOAGRep  = T_LOAGRep {
                               T_LOAGRep -> Identity T_LOAGRep_s62
attach_T_LOAGRep :: Identity (T_LOAGRep_s62 )
                               }
newtype T_LOAGRep_s62  = C_LOAGRep_s62 {
                                       T_LOAGRep_s62 -> T_LOAGRep_v61
inv_LOAGRep_s62 :: (T_LOAGRep_v61 )
                                       }
data T_LOAGRep_s63  = C_LOAGRep_s63
type T_LOAGRep_v61  = (T_LOAGRep_vIn61 ) -> (T_LOAGRep_vOut61 )
data T_LOAGRep_vIn61  = T_LOAGRep_vIn61 
data T_LOAGRep_vOut61  = T_LOAGRep_vOut61 (LOAGRep)
{-# NOINLINE sem_LOAGRep_LOAGRep #-}
sem_LOAGRep_LOAGRep :: ([PLabel]) -> (A_P) -> (A_N) -> (AI_N) -> (AS_N) -> (SF_P) -> (PMP) -> (PMP_R) -> (NMP) -> (NMP_R) -> (A.Array Int Int) -> (A.Array Int [Int]) -> (A.Array Int Int) -> (FTY) -> (FMap) -> (Map.Map PLabel [(PLabel,FLabel)]) -> T_LOAGRep 
sem_LOAGRep_LOAGRep :: [PLabel]
-> A_P
-> AI_N
-> AI_N
-> AI_N
-> SF_P
-> PMP
-> PMP_R
-> NMP
-> NMP_R
-> Array Int Int
-> Array Int [Int]
-> Array Int Int
-> FTY
-> FMap
-> Map PLabel [(PLabel, FLabel)]
-> T_LOAGRep
sem_LOAGRep_LOAGRep [PLabel]
arg_ps_ A_P
arg_ap_ AI_N
arg_an_ AI_N
arg_ain_ AI_N
arg_asn_ SF_P
arg_sfp_ PMP
arg_pmp_ PMP_R
arg_pmpr_ NMP
arg_nmp_ NMP_R
arg_nmpr_ Array Int Int
arg_gen_ Array Int [Int]
arg_inss_ Array Int Int
arg_ofld_ FTY
arg_fty_ FMap
arg_fieldMap_ Map PLabel [(PLabel, FLabel)]
arg_fsInP_ = Identity T_LOAGRep_s62 -> T_LOAGRep
T_LOAGRep (forall (m :: * -> *) a. Monad m => a -> m a
return T_LOAGRep_s62
st62) where
   {-# NOINLINE st62 #-}
   st62 :: T_LOAGRep_s62
st62 = let
      v61 :: T_LOAGRep_v61 
      v61 :: T_LOAGRep_v61
v61 = \ (T_LOAGRep_vIn61
T_LOAGRep_vIn61 ) -> ( let
         _self :: LOAGRep
_self = AI_N
-> AI_N
-> A_P
-> AI_N
-> FMap
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Array Int Int
-> Array Int [Int]
-> NMP
-> NMP_R
-> Array Int Int
-> PMP
-> PMP_R
-> [PLabel]
-> SF_P
-> LOAGRep
rule290 AI_N
arg_ain_ AI_N
arg_an_ A_P
arg_ap_ AI_N
arg_asn_ FMap
arg_fieldMap_ Map PLabel [(PLabel, FLabel)]
arg_fsInP_ FTY
arg_fty_ Array Int Int
arg_gen_ Array Int [Int]
arg_inss_ NMP
arg_nmp_ NMP_R
arg_nmpr_ Array Int Int
arg_ofld_ PMP
arg_pmp_ PMP_R
arg_pmpr_ [PLabel]
arg_ps_ SF_P
arg_sfp_
         _lhsOself :: LOAGRep
         _lhsOself :: LOAGRep
_lhsOself = forall a. a -> a
rule291 LOAGRep
_self
         __result_ :: T_LOAGRep_vOut61
__result_ = LOAGRep -> T_LOAGRep_vOut61
T_LOAGRep_vOut61 LOAGRep
_lhsOself
         in T_LOAGRep_vOut61
__result_ )
     in T_LOAGRep_v61 -> T_LOAGRep_s62
C_LOAGRep_s62 T_LOAGRep_v61
v61
   {-# INLINE rule290 #-}
   rule290 :: AI_N
-> AI_N
-> A_P
-> AI_N
-> FMap
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Array Int Int
-> Array Int [Int]
-> NMP
-> NMP_R
-> Array Int Int
-> PMP
-> PMP_R
-> [PLabel]
-> SF_P
-> LOAGRep
rule290 = \ AI_N
ain_ AI_N
an_ A_P
ap_ AI_N
asn_ FMap
fieldMap_ Map PLabel [(PLabel, FLabel)]
fsInP_ FTY
fty_ Array Int Int
gen_ Array Int [Int]
inss_ NMP
nmp_ NMP_R
nmpr_ Array Int Int
ofld_ PMP
pmp_ PMP_R
pmpr_ [PLabel]
ps_ SF_P
sfp_ ->
     [PLabel]
-> A_P
-> AI_N
-> AI_N
-> AI_N
-> SF_P
-> PMP
-> PMP_R
-> NMP
-> NMP_R
-> Array Int Int
-> Array Int [Int]
-> Array Int Int
-> FTY
-> FMap
-> Map PLabel [(PLabel, FLabel)]
-> LOAGRep
LOAGRep [PLabel]
ps_ A_P
ap_ AI_N
an_ AI_N
ain_ AI_N
asn_ SF_P
sfp_ PMP
pmp_ PMP_R
pmpr_ NMP
nmp_ NMP_R
nmpr_ Array Int Int
gen_ Array Int [Int]
inss_ Array Int Int
ofld_ FTY
fty_ FMap
fieldMap_ Map PLabel [(PLabel, FLabel)]
fsInP_
   {-# INLINE rule291 #-}
   rule291 :: p -> p
rule291 = \ p
_self ->
     p
_self

-- MySegment ---------------------------------------------------
-- wrapper
data Inh_MySegment  = Inh_MySegment { Inh_MySegment -> MyType -> MyAttributes
ain_Inh_MySegment :: (MyType -> MyAttributes), Inh_MySegment -> MyType -> MyAttributes
asn_Inh_MySegment :: (MyType -> MyAttributes), Inh_MySegment
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
done_Inh_MySegment :: ( (Set.Set MyOccurrence, Set.Set FLabel
                                                                                                                                                                           , Set.Set Identifier, Set.Set (FLabel,Int))), Inh_MySegment -> FTY
fty_Inh_MySegment :: (FTY), Inh_MySegment -> HOMap
hoMapf_Inh_MySegment :: (HOMap), Inh_MySegment -> SF_P
lfpf_Inh_MySegment :: (SF_P), Inh_MySegment -> NMP
nmp_Inh_MySegment :: (NMP), Inh_MySegment -> NMP_R
nmprf_Inh_MySegment :: (NMP_R), Inh_MySegment -> Options
options_Inh_MySegment :: (Options), Inh_MySegment -> PMP
pmpf_Inh_MySegment :: (PMP), Inh_MySegment -> PMP_R
pmprf_Inh_MySegment :: (PMP_R), Inh_MySegment -> PLabel
ps_Inh_MySegment :: (PLabel), Inh_MySegment -> Map MyOccurrence NontermIdent
ruleMap_Inh_MySegment :: (Map.Map MyOccurrence Identifier), Inh_MySegment -> TDPRes
tdp_Inh_MySegment :: (TDPRes), Inh_MySegment -> IntMap Int
visMapf_Inh_MySegment :: (IMap.IntMap Int), Inh_MySegment -> Int
visitnum_Inh_MySegment :: (Int) }
data Syn_MySegment  = Syn_MySegment { Syn_MySegment
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
done_Syn_MySegment :: ( (Set.Set MyOccurrence, Set.Set FLabel
                                                                             ,Set.Set Identifier, Set.Set (FLabel,Int))), Syn_MySegment -> Visit
evisits_Syn_MySegment :: (Visit), Syn_MySegment -> MySegment
self_Syn_MySegment :: (MySegment), Syn_MySegment -> [Int]
synsO_Syn_MySegment :: ([Int]), Syn_MySegment -> Int
visitnum_Syn_MySegment :: (Int), Syn_MySegment -> Int
visnr_Syn_MySegment :: (Int) }
{-# INLINABLE wrap_MySegment #-}
wrap_MySegment :: T_MySegment  -> Inh_MySegment  -> (Syn_MySegment )
wrap_MySegment :: T_MySegment -> Inh_MySegment -> Syn_MySegment
wrap_MySegment (T_MySegment Identity T_MySegment_s65
act) (Inh_MySegment MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_MySegment_s65
sem <- Identity T_MySegment_s65
act
        let arg64 :: T_MySegment_vIn64
arg64 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
-> FTY
-> HOMap
-> SF_P
-> NMP
-> NMP_R
-> Options
-> PMP
-> PMP_R
-> PLabel
-> Map MyOccurrence NontermIdent
-> TDPRes
-> IntMap Int
-> Int
-> T_MySegment_vIn64
T_MySegment_vIn64 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum
        (T_MySegment_vOut64 (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsOdone Visit
_lhsOevisits MySegment
_lhsOself [Int]
_lhsOsynsO Int
_lhsOvisitnum Int
_lhsOvisnr) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_MySegment_s65 -> T_MySegment_v64
inv_MySegment_s65 T_MySegment_s65
sem T_MySegment_vIn64
arg64)
        forall (m :: * -> *) a. Monad m => a -> m a
return ((Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
-> Visit -> MySegment -> [Int] -> Int -> Int -> Syn_MySegment
Syn_MySegment (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsOdone Visit
_lhsOevisits MySegment
_lhsOself [Int]
_lhsOsynsO Int
_lhsOvisitnum Int
_lhsOvisnr)
   )

-- cata
{-# INLINE sem_MySegment #-}
sem_MySegment :: MySegment  -> T_MySegment 
sem_MySegment :: MySegment -> T_MySegment
sem_MySegment ( MySegment Int
visnr_ [Int]
inhAttr_ [Int]
synAttr_ Maybe [Int]
inhOccs_ Maybe [Int]
synOccs_ ) = Int -> [Int] -> [Int] -> Maybe [Int] -> Maybe [Int] -> T_MySegment
sem_MySegment_MySegment Int
visnr_ [Int]
inhAttr_ [Int]
synAttr_ Maybe [Int]
inhOccs_ Maybe [Int]
synOccs_

-- semantic domain
newtype T_MySegment  = T_MySegment {
                                   T_MySegment -> Identity T_MySegment_s65
attach_T_MySegment :: Identity (T_MySegment_s65 )
                                   }
newtype T_MySegment_s65  = C_MySegment_s65 {
                                           T_MySegment_s65 -> T_MySegment_v64
inv_MySegment_s65 :: (T_MySegment_v64 )
                                           }
data T_MySegment_s66  = C_MySegment_s66
type T_MySegment_v64  = (T_MySegment_vIn64 ) -> (T_MySegment_vOut64 )
data T_MySegment_vIn64  = T_MySegment_vIn64 (MyType -> MyAttributes) (MyType -> MyAttributes) ( (Set.Set MyOccurrence, Set.Set FLabel
                                                                                                               , Set.Set Identifier, Set.Set (FLabel,Int))) (FTY) (HOMap) (SF_P) (NMP) (NMP_R) (Options) (PMP) (PMP_R) (PLabel) (Map.Map MyOccurrence Identifier) (TDPRes) (IMap.IntMap Int) (Int)
data T_MySegment_vOut64  = T_MySegment_vOut64 ( (Set.Set MyOccurrence, Set.Set FLabel
                                                               ,Set.Set Identifier, Set.Set (FLabel,Int))) (Visit) (MySegment) ([Int]) (Int) (Int)
{-# NOINLINE sem_MySegment_MySegment #-}
sem_MySegment_MySegment :: (Int) -> ([Int]) -> ([Int]) -> (Maybe [Int]) -> (Maybe [Int]) -> T_MySegment 
sem_MySegment_MySegment :: Int -> [Int] -> [Int] -> Maybe [Int] -> Maybe [Int] -> T_MySegment
sem_MySegment_MySegment Int
arg_visnr_ [Int]
arg_inhAttr_ [Int]
arg_synAttr_ Maybe [Int]
arg_inhOccs_ Maybe [Int]
arg_synOccs_ = Identity T_MySegment_s65 -> T_MySegment
T_MySegment (forall (m :: * -> *) a. Monad m => a -> m a
return T_MySegment_s65
st65) where
   {-# NOINLINE st65 #-}
   st65 :: T_MySegment_s65
st65 = let
      v64 :: T_MySegment_v64 
      v64 :: T_MySegment_v64
v64 = \ (T_MySegment_vIn64 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = forall {b}. (b -> b) -> b -> b
rule292 Int -> Int
_visitnum_augmented_f1 Int
_visitnum_augmented_syn
         _visitnum_augmented_f1 :: Int -> Int
_visitnum_augmented_f1 = () -> Int -> Int
rule293  ()
         _inhs :: Set NontermIdent
_inhs = NMP -> [Int] -> Set NontermIdent
rule294 NMP
_lhsInmp [Int]
arg_inhAttr_
         _syns :: Set NontermIdent
_syns = NMP -> [Int] -> Set NontermIdent
rule295 NMP
_lhsInmp [Int]
arg_synAttr_
         _inhsO :: [Int]
_inhsO = forall {b}. Maybe b -> b
rule296 Maybe [Int]
arg_inhOccs_
         _synsO :: [Int]
_synsO = forall {b}. Maybe b -> b
rule297 Maybe [Int]
arg_synOccs_
         _lhsOvisnr :: Int
         _lhsOvisnr :: Int
_lhsOvisnr = forall a. a -> a
rule298 Int
arg_visnr_
         _kind :: VisitKind
_kind = Options -> VisitKind
rule299 Options
_lhsIoptions
         _lhsOevisits :: Visit
         _lhsOevisits :: Visit
_lhsOevisits = Set NontermIdent
-> VisitKind -> Int -> [VisitStep] -> Set NontermIdent -> Visit
rule300 Set NontermIdent
_inhs VisitKind
_kind Int
_lhsIvisitnum [VisitStep]
_steps Set NontermIdent
_syns
         _steps :: [VisitStep]
_steps = Options -> [VisitStep] -> [VisitStep]
rule301 Options
_lhsIoptions [VisitStep]
_vss
         _lhsOdone ::  (Set.Set MyOccurrence, Set.Set FLabel
                                      ,Set.Set Identifier, Set.Set (FLabel,Int))
         ([VisitStep]
_vss,(Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsOdone) = (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
-> FTY
-> HOMap
-> SF_P
-> NMP_R
-> PMP
-> PMP_R
-> PLabel
-> Map MyOccurrence NontermIdent
-> TDPRes
-> IntMap Int
-> [Int]
-> ([VisitStep],
    (Set MyOccurrence, Set FLabel, Set NontermIdent,
     Set (FLabel, Int)))
rule302 (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP_R
_lhsInmprf PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf [Int]
_synsO
         _self :: MySegment
_self = [Int] -> Maybe [Int] -> [Int] -> Maybe [Int] -> Int -> MySegment
rule303 [Int]
arg_inhAttr_ Maybe [Int]
arg_inhOccs_ [Int]
arg_synAttr_ Maybe [Int]
arg_synOccs_ Int
arg_visnr_
         _lhsOself :: MySegment
         _lhsOself :: MySegment
_lhsOself = forall a. a -> a
rule304 MySegment
_self
         _lhsOsynsO :: [Int]
         _lhsOsynsO :: [Int]
_lhsOsynsO = forall a. a -> a
rule305 [Int]
_synsO
         _visitnum_augmented_syn :: Int
_visitnum_augmented_syn = Int -> Int
rule306 Int
_lhsIvisitnum
         __result_ :: T_MySegment_vOut64
__result_ = (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
-> Visit -> MySegment -> [Int] -> Int -> Int -> T_MySegment_vOut64
T_MySegment_vOut64 (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsOdone Visit
_lhsOevisits MySegment
_lhsOself [Int]
_lhsOsynsO Int
_lhsOvisitnum Int
_lhsOvisnr
         in T_MySegment_vOut64
__result_ )
     in T_MySegment_v64 -> T_MySegment_s65
C_MySegment_s65 T_MySegment_v64
v64
   {-# INLINE rule292 #-}
   rule292 :: (b -> b) -> b -> b
rule292 = \ b -> b
_visitnum_augmented_f1 b
_visitnum_augmented_syn ->
     forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a b. (a -> b) -> a -> b
($) b
_visitnum_augmented_syn [b -> b
_visitnum_augmented_f1]
   {-# INLINE rule293 #-}
   rule293 :: () -> Int -> Int
rule293 = \  (()
_ :: ()) ->
                                        (forall a. Num a => a -> a -> a
+Int
1)
   {-# INLINE rule294 #-}
   {-# LINE 225 "src-ag/LOAG/Order.ag" #-}
   rule294 = \ ((_lhsInmp) :: NMP) inhAttr_ ->
                   {-# LINE 225 "src-ag/LOAG/Order.ag" #-}
                   Map.keysSet$ Map.unions $ map (vertexToAttr _lhsInmp) inhAttr_
                   {-# LINE 3043 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule295 #-}
   {-# LINE 226 "src-ag/LOAG/Order.ag" #-}
   rule295 = \ ((_lhsInmp) :: NMP) synAttr_ ->
                   {-# LINE 226 "src-ag/LOAG/Order.ag" #-}
                   Map.keysSet$ Map.unions $ map (vertexToAttr _lhsInmp) synAttr_
                   {-# LINE 3049 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule296 #-}
   {-# LINE 227 "src-ag/LOAG/Order.ag" #-}
   rule296 = \ inhOccs_ ->
                   {-# LINE 227 "src-ag/LOAG/Order.ag" #-}
                   maybe (error "segment not instantiated") id inhOccs_
                   {-# LINE 3055 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule297 #-}
   {-# LINE 228 "src-ag/LOAG/Order.ag" #-}
   rule297 = \ synOccs_ ->
                   {-# LINE 228 "src-ag/LOAG/Order.ag" #-}
                   maybe (error "segment not instantiated") id synOccs_
                   {-# LINE 3061 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule298 #-}
   {-# LINE 229 "src-ag/LOAG/Order.ag" #-}
   rule298 = \ visnr_ ->
                   {-# LINE 229 "src-ag/LOAG/Order.ag" #-}
                   visnr_
                   {-# LINE 3067 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule299 #-}
   {-# LINE 230 "src-ag/LOAG/Order.ag" #-}
   rule299 = \ ((_lhsIoptions) :: Options) ->
                   {-# LINE 230 "src-ag/LOAG/Order.ag" #-}
                   if monadic _lhsIoptions then VisitMonadic else VisitPure True
                   {-# LINE 3073 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule300 #-}
   {-# LINE 231 "src-ag/LOAG/Order.ag" #-}
   rule300 = \ _inhs _kind ((_lhsIvisitnum) :: Int) _steps _syns ->
                      {-# LINE 231 "src-ag/LOAG/Order.ag" #-}
                      Visit _lhsIvisitnum _lhsIvisitnum (_lhsIvisitnum+1)
                            _inhs     _syns     _steps     _kind
                      {-# LINE 3080 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule301 #-}
   {-# LINE 233 "src-ag/LOAG/Order.ag" #-}
   rule301 = \ ((_lhsIoptions) :: Options) _vss ->
                      {-# LINE 233 "src-ag/LOAG/Order.ag" #-}
                      if monadic _lhsIoptions
                          then [Sim _vss    ] else [PureGroup _vss     True]
                      {-# LINE 3087 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule302 #-}
   {-# LINE 235 "src-ag/LOAG/Order.ag" #-}
   rule302 = \ ((_lhsIdone) ::  (Set.Set MyOccurrence, Set.Set FLabel
                                               , Set.Set Identifier, Set.Set (FLabel,Int))) ((_lhsIfty) :: FTY) ((_lhsIhoMapf) :: HOMap) ((_lhsIlfpf) :: SF_P) ((_lhsInmprf) :: NMP_R) ((_lhsIpmpf) :: PMP) ((_lhsIpmprf) :: PMP_R) ((_lhsIps) :: PLabel) ((_lhsIruleMap) :: Map.Map MyOccurrence Identifier) ((_lhsItdp) :: TDPRes) ((_lhsIvisMapf) :: IMap.IntMap Int) _synsO ->
                             {-# LINE 235 "src-ag/LOAG/Order.ag" #-}
                             (runST $ getVss _lhsIdone _lhsIps _lhsItdp _synsO
                              _lhsIlfpf _lhsInmprf _lhsIpmpf _lhsIpmprf _lhsIfty
                              _lhsIvisMapf _lhsIruleMap _lhsIhoMapf)
                             {-# LINE 3096 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule303 #-}
   rule303 = \ inhAttr_ inhOccs_ synAttr_ synOccs_ visnr_ ->
     MySegment visnr_ inhAttr_ synAttr_ inhOccs_ synOccs_
   {-# INLINE rule304 #-}
   rule304 = \ _self ->
     _self
   {-# INLINE rule305 #-}
   rule305 = \ _synsO ->
     _synsO
   {-# INLINE rule306 #-}
   rule306 = \ ((_lhsIvisitnum) :: Int) ->
     _lhsIvisitnum

-- MySegments --------------------------------------------------
-- wrapper
data Inh_MySegments  = Inh_MySegments { Inh_MySegments -> MyType -> MyAttributes
ain_Inh_MySegments :: (MyType -> MyAttributes), Inh_MySegments -> MyType -> MyAttributes
asn_Inh_MySegments :: (MyType -> MyAttributes), Inh_MySegments
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
done_Inh_MySegments :: ( (Set.Set MyOccurrence, Set.Set FLabel
                                                                                                                                                                                , Set.Set Identifier, Set.Set (FLabel,Int))), Inh_MySegments -> FTY
fty_Inh_MySegments :: (FTY), Inh_MySegments -> HOMap
hoMapf_Inh_MySegments :: (HOMap), Inh_MySegments -> SF_P
lfpf_Inh_MySegments :: (SF_P), Inh_MySegments -> NMP
nmp_Inh_MySegments :: (NMP), Inh_MySegments -> NMP_R
nmprf_Inh_MySegments :: (NMP_R), Inh_MySegments -> Options
options_Inh_MySegments :: (Options), Inh_MySegments -> PMP
pmpf_Inh_MySegments :: (PMP), Inh_MySegments -> PMP_R
pmprf_Inh_MySegments :: (PMP_R), Inh_MySegments -> PLabel
ps_Inh_MySegments :: (PLabel), Inh_MySegments -> Map MyOccurrence NontermIdent
ruleMap_Inh_MySegments :: (Map.Map MyOccurrence Identifier), Inh_MySegments -> TDPRes
tdp_Inh_MySegments :: (TDPRes), Inh_MySegments -> IntMap Int
visMapf_Inh_MySegments :: (IMap.IntMap Int), Inh_MySegments -> Int
visitnum_Inh_MySegments :: (Int) }
data Syn_MySegments  = Syn_MySegments { Syn_MySegments -> Visits
evisits_Syn_MySegments :: (Visits), Syn_MySegments -> [MySegment]
self_Syn_MySegments :: (MySegments), Syn_MySegments -> Int
visitnum_Syn_MySegments :: (Int) }
{-# INLINABLE wrap_MySegments #-}
wrap_MySegments :: T_MySegments  -> Inh_MySegments  -> (Syn_MySegments )
wrap_MySegments :: T_MySegments -> Inh_MySegments -> Syn_MySegments
wrap_MySegments (T_MySegments Identity T_MySegments_s68
act) (Inh_MySegments MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_MySegments_s68
sem <- Identity T_MySegments_s68
act
        let arg67 :: T_MySegments_vIn67
arg67 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
-> FTY
-> HOMap
-> SF_P
-> NMP
-> NMP_R
-> Options
-> PMP
-> PMP_R
-> PLabel
-> Map MyOccurrence NontermIdent
-> TDPRes
-> IntMap Int
-> Int
-> T_MySegments_vIn67
T_MySegments_vIn67 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum
        (T_MySegments_vOut67 Visits
_lhsOevisits [MySegment]
_lhsOself Int
_lhsOvisitnum) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_MySegments_s68 -> T_MySegments_v67
inv_MySegments_s68 T_MySegments_s68
sem T_MySegments_vIn67
arg67)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Visits -> [MySegment] -> Int -> Syn_MySegments
Syn_MySegments Visits
_lhsOevisits [MySegment]
_lhsOself Int
_lhsOvisitnum)
   )

-- cata
{-# NOINLINE sem_MySegments #-}
sem_MySegments :: MySegments  -> T_MySegments 
sem_MySegments :: [MySegment] -> T_MySegments
sem_MySegments [MySegment]
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_MySegment -> T_MySegments -> T_MySegments
sem_MySegments_Cons T_MySegments
sem_MySegments_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map MySegment -> T_MySegment
sem_MySegment [MySegment]
list)

-- semantic domain
newtype T_MySegments  = T_MySegments {
                                     T_MySegments -> Identity T_MySegments_s68
attach_T_MySegments :: Identity (T_MySegments_s68 )
                                     }
newtype T_MySegments_s68  = C_MySegments_s68 {
                                             T_MySegments_s68 -> T_MySegments_v67
inv_MySegments_s68 :: (T_MySegments_v67 )
                                             }
data T_MySegments_s69  = C_MySegments_s69
type T_MySegments_v67  = (T_MySegments_vIn67 ) -> (T_MySegments_vOut67 )
data T_MySegments_vIn67  = T_MySegments_vIn67 (MyType -> MyAttributes) (MyType -> MyAttributes) ( (Set.Set MyOccurrence, Set.Set FLabel
                                                                                                                 , Set.Set Identifier, Set.Set (FLabel,Int))) (FTY) (HOMap) (SF_P) (NMP) (NMP_R) (Options) (PMP) (PMP_R) (PLabel) (Map.Map MyOccurrence Identifier) (TDPRes) (IMap.IntMap Int) (Int)
data T_MySegments_vOut67  = T_MySegments_vOut67 (Visits) (MySegments) (Int)
{-# NOINLINE sem_MySegments_Cons #-}
sem_MySegments_Cons :: T_MySegment  -> T_MySegments  -> T_MySegments 
sem_MySegments_Cons :: T_MySegment -> T_MySegments -> T_MySegments
sem_MySegments_Cons T_MySegment
arg_hd_ T_MySegments
arg_tl_ = Identity T_MySegments_s68 -> T_MySegments
T_MySegments (forall (m :: * -> *) a. Monad m => a -> m a
return T_MySegments_s68
st68) where
   {-# NOINLINE st68 #-}
   st68 :: T_MySegments_s68
st68 = let
      v67 :: T_MySegments_v67 
      v67 :: T_MySegments_v67
v67 = \ (T_MySegments_vIn67 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _hdX65 :: T_MySegment_s65
_hdX65 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_MySegment -> Identity T_MySegment_s65
attach_T_MySegment (T_MySegment
arg_hd_))
         _tlX68 :: T_MySegments_s68
_tlX68 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_MySegments -> Identity T_MySegments_s68
attach_T_MySegments (T_MySegments
arg_tl_))
         (T_MySegment_vOut64 (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_hdIdone Visit
_hdIevisits MySegment
_hdIself [Int]
_hdIsynsO Int
_hdIvisitnum Int
_hdIvisnr) = T_MySegment_s65 -> T_MySegment_v64
inv_MySegment_s65 T_MySegment_s65
_hdX65 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
-> FTY
-> HOMap
-> SF_P
-> NMP
-> NMP_R
-> Options
-> PMP
-> PMP_R
-> PLabel
-> Map MyOccurrence NontermIdent
-> TDPRes
-> IntMap Int
-> Int
-> T_MySegment_vIn64
T_MySegment_vIn64 MyType -> MyAttributes
_hdOain MyType -> MyAttributes
_hdOasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_hdOdone FTY
_hdOfty HOMap
_hdOhoMapf SF_P
_hdOlfpf NMP
_hdOnmp NMP_R
_hdOnmprf Options
_hdOoptions PMP
_hdOpmpf PMP_R
_hdOpmprf PLabel
_hdOps Map MyOccurrence NontermIdent
_hdOruleMap TDPRes
_hdOtdp IntMap Int
_hdOvisMapf Int
_hdOvisitnum)
         (T_MySegments_vOut67 Visits
_tlIevisits [MySegment]
_tlIself Int
_tlIvisitnum) = T_MySegments_s68 -> T_MySegments_v67
inv_MySegments_s68 T_MySegments_s68
_tlX68 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
-> FTY
-> HOMap
-> SF_P
-> NMP
-> NMP_R
-> Options
-> PMP
-> PMP_R
-> PLabel
-> Map MyOccurrence NontermIdent
-> TDPRes
-> IntMap Int
-> Int
-> T_MySegments_vIn67
T_MySegments_vIn67 MyType -> MyAttributes
_tlOain MyType -> MyAttributes
_tlOasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_tlOdone FTY
_tlOfty HOMap
_tlOhoMapf SF_P
_tlOlfpf NMP
_tlOnmp NMP_R
_tlOnmprf Options
_tlOoptions PMP
_tlOpmpf PMP_R
_tlOpmprf PLabel
_tlOps Map MyOccurrence NontermIdent
_tlOruleMap TDPRes
_tlOtdp IntMap Int
_tlOvisMapf Int
_tlOvisitnum)
         _hdOdone :: (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_hdOdone = (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
rule307 (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone
         _tlOdone :: (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_tlOdone = (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
rule308 (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_hdIdone
         _lhsOevisits :: Visits
         _lhsOevisits :: Visits
_lhsOevisits = Visit -> Visits -> Visits
rule309 Visit
_hdIevisits Visits
_tlIevisits
         _self :: [MySegment]
_self = MySegment -> [MySegment] -> [MySegment]
rule310 MySegment
_hdIself [MySegment]
_tlIself
         _lhsOself :: MySegments
         _lhsOself :: [MySegment]
_lhsOself = forall a. a -> a
rule311 [MySegment]
_self
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule312 Int
_tlIvisitnum
         _hdOain :: MyType -> MyAttributes
_hdOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule313 MyType -> MyAttributes
_lhsIain
         _hdOasn :: MyType -> MyAttributes
_hdOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule314 MyType -> MyAttributes
_lhsIasn
         _hdOfty :: FTY
_hdOfty = FTY -> FTY
rule315 FTY
_lhsIfty
         _hdOhoMapf :: HOMap
_hdOhoMapf = HOMap -> HOMap
rule316 HOMap
_lhsIhoMapf
         _hdOlfpf :: SF_P
_hdOlfpf = SF_P -> SF_P
rule317 SF_P
_lhsIlfpf
         _hdOnmp :: NMP
_hdOnmp = NMP -> NMP
rule318 NMP
_lhsInmp
         _hdOnmprf :: NMP_R
_hdOnmprf = NMP_R -> NMP_R
rule319 NMP_R
_lhsInmprf
         _hdOoptions :: Options
_hdOoptions = Options -> Options
rule320 Options
_lhsIoptions
         _hdOpmpf :: PMP
_hdOpmpf = PMP -> PMP
rule321 PMP
_lhsIpmpf
         _hdOpmprf :: PMP_R
_hdOpmprf = PMP_R -> PMP_R
rule322 PMP_R
_lhsIpmprf
         _hdOps :: PLabel
_hdOps = PLabel -> PLabel
rule323 PLabel
_lhsIps
         _hdOruleMap :: Map MyOccurrence NontermIdent
_hdOruleMap = Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule324 Map MyOccurrence NontermIdent
_lhsIruleMap
         _hdOtdp :: TDPRes
_hdOtdp = TDPRes -> TDPRes
rule325 TDPRes
_lhsItdp
         _hdOvisMapf :: IntMap Int
_hdOvisMapf = IntMap Int -> IntMap Int
rule326 IntMap Int
_lhsIvisMapf
         _hdOvisitnum :: Int
_hdOvisitnum = Int -> Int
rule327 Int
_lhsIvisitnum
         _tlOain :: MyType -> MyAttributes
_tlOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule328 MyType -> MyAttributes
_lhsIain
         _tlOasn :: MyType -> MyAttributes
_tlOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule329 MyType -> MyAttributes
_lhsIasn
         _tlOfty :: FTY
_tlOfty = FTY -> FTY
rule330 FTY
_lhsIfty
         _tlOhoMapf :: HOMap
_tlOhoMapf = HOMap -> HOMap
rule331 HOMap
_lhsIhoMapf
         _tlOlfpf :: SF_P
_tlOlfpf = SF_P -> SF_P
rule332 SF_P
_lhsIlfpf
         _tlOnmp :: NMP
_tlOnmp = NMP -> NMP
rule333 NMP
_lhsInmp
         _tlOnmprf :: NMP_R
_tlOnmprf = NMP_R -> NMP_R
rule334 NMP_R
_lhsInmprf
         _tlOoptions :: Options
_tlOoptions = Options -> Options
rule335 Options
_lhsIoptions
         _tlOpmpf :: PMP
_tlOpmpf = PMP -> PMP
rule336 PMP
_lhsIpmpf
         _tlOpmprf :: PMP_R
_tlOpmprf = PMP_R -> PMP_R
rule337 PMP_R
_lhsIpmprf
         _tlOps :: PLabel
_tlOps = PLabel -> PLabel
rule338 PLabel
_lhsIps
         _tlOruleMap :: Map MyOccurrence NontermIdent
_tlOruleMap = Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule339 Map MyOccurrence NontermIdent
_lhsIruleMap
         _tlOtdp :: TDPRes
_tlOtdp = TDPRes -> TDPRes
rule340 TDPRes
_lhsItdp
         _tlOvisMapf :: IntMap Int
_tlOvisMapf = IntMap Int -> IntMap Int
rule341 IntMap Int
_lhsIvisMapf
         _tlOvisitnum :: Int
_tlOvisitnum = Int -> Int
rule342 Int
_hdIvisitnum
         __result_ :: T_MySegments_vOut67
__result_ = Visits -> [MySegment] -> Int -> T_MySegments_vOut67
T_MySegments_vOut67 Visits
_lhsOevisits [MySegment]
_lhsOself Int
_lhsOvisitnum
         in T_MySegments_vOut67
__result_ )
     in T_MySegments_v67 -> T_MySegments_s68
C_MySegments_s68 T_MySegments_v67
v67
   {-# INLINE rule307 #-}
   {-# LINE 220 "src-ag/LOAG/Order.ag" #-}
   rule307 = \ ((_lhsIdone) ::  (Set.Set MyOccurrence, Set.Set FLabel
                                               , Set.Set Identifier, Set.Set (FLabel,Int))) ->
                        {-# LINE 220 "src-ag/LOAG/Order.ag" #-}
                        _lhsIdone
                        {-# LINE 3201 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule308 #-}
   {-# LINE 221 "src-ag/LOAG/Order.ag" #-}
   rule308 = \ ((_hdIdone) ::  (Set.Set MyOccurrence, Set.Set FLabel
                                              ,Set.Set Identifier, Set.Set (FLabel,Int))) ->
                        {-# LINE 221 "src-ag/LOAG/Order.ag" #-}
                        _hdIdone
                        {-# LINE 3208 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule309 #-}
   rule309 = \ ((_hdIevisits) :: Visit) ((_tlIevisits) :: Visits) ->
     _hdIevisits : _tlIevisits
   {-# INLINE rule310 #-}
   rule310 = \ ((_hdIself) :: MySegment) ((_tlIself) :: MySegments) ->
     (:) _hdIself _tlIself
   {-# INLINE rule311 #-}
   rule311 = \ _self ->
     _self
   {-# INLINE rule312 #-}
   rule312 = \ ((_tlIvisitnum) :: Int) ->
     _tlIvisitnum
   {-# INLINE rule313 #-}
   rule313 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule314 #-}
   rule314 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule315 #-}
   rule315 = \ ((_lhsIfty) :: FTY) ->
     _lhsIfty
   {-# INLINE rule316 #-}
   rule316 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule317 #-}
   rule317 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule318 #-}
   rule318 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule319 #-}
   rule319 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule320 #-}
   rule320 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule321 #-}
   rule321 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule322 #-}
   rule322 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule323 #-}
   rule323 = \ ((_lhsIps) :: PLabel) ->
     _lhsIps
   {-# INLINE rule324 #-}
   rule324 = \ ((_lhsIruleMap) :: Map.Map MyOccurrence Identifier) ->
     _lhsIruleMap
   {-# INLINE rule325 #-}
   rule325 = \ ((_lhsItdp) :: TDPRes) ->
     _lhsItdp
   {-# INLINE rule326 #-}
   rule326 = \ ((_lhsIvisMapf) :: IMap.IntMap Int) ->
     _lhsIvisMapf
   {-# INLINE rule327 #-}
   rule327 = \ ((_lhsIvisitnum) :: Int) ->
     _lhsIvisitnum
   {-# INLINE rule328 #-}
   rule328 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule329 #-}
   rule329 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule330 #-}
   rule330 = \ ((_lhsIfty) :: FTY) ->
     _lhsIfty
   {-# INLINE rule331 #-}
   rule331 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule332 #-}
   rule332 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule333 #-}
   rule333 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule334 #-}
   rule334 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule335 #-}
   rule335 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule336 #-}
   rule336 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule337 #-}
   rule337 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule338 #-}
   rule338 = \ ((_lhsIps) :: PLabel) ->
     _lhsIps
   {-# INLINE rule339 #-}
   rule339 = \ ((_lhsIruleMap) :: Map.Map MyOccurrence Identifier) ->
     _lhsIruleMap
   {-# INLINE rule340 #-}
   rule340 = \ ((_lhsItdp) :: TDPRes) ->
     _lhsItdp
   {-# INLINE rule341 #-}
   rule341 = \ ((_lhsIvisMapf) :: IMap.IntMap Int) ->
     _lhsIvisMapf
   {-# INLINE rule342 #-}
   rule342 = \ ((_hdIvisitnum) :: Int) ->
     _hdIvisitnum
{-# NOINLINE sem_MySegments_Nil #-}
sem_MySegments_Nil ::  T_MySegments 
sem_MySegments_Nil :: T_MySegments
sem_MySegments_Nil  = Identity T_MySegments_s68 -> T_MySegments
T_MySegments (forall (m :: * -> *) a. Monad m => a -> m a
return T_MySegments_s68
st68) where
   {-# NOINLINE st68 #-}
   st68 :: T_MySegments_s68
st68 = let
      v67 :: T_MySegments_v67 
      v67 :: T_MySegments_v67
v67 = \ (T_MySegments_vIn67 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIasn (Set MyOccurrence, Set FLabel, Set NontermIdent, Set (FLabel, Int))
_lhsIdone FTY
_lhsIfty HOMap
_lhsIhoMapf SF_P
_lhsIlfpf NMP
_lhsInmp NMP_R
_lhsInmprf Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf PLabel
_lhsIps Map MyOccurrence NontermIdent
_lhsIruleMap TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _lhsOevisits :: Visits
         _lhsOevisits :: Visits
_lhsOevisits = forall {a}. () -> [a]
rule343  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule344  ()
         _lhsOself :: MySegments
         _lhsOself :: [MySegment]
_lhsOself = forall a. a -> a
rule345 forall a. [a]
_self
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule346 Int
_lhsIvisitnum
         __result_ :: T_MySegments_vOut67
__result_ = Visits -> [MySegment] -> Int -> T_MySegments_vOut67
T_MySegments_vOut67 Visits
_lhsOevisits [MySegment]
_lhsOself Int
_lhsOvisitnum
         in T_MySegments_vOut67
__result_ )
     in T_MySegments_v67 -> T_MySegments_s68
C_MySegments_s68 T_MySegments_v67
v67
   {-# INLINE rule343 #-}
   rule343 :: () -> [a]
rule343 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule344 #-}
   rule344 :: () -> [a]
rule344 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule345 #-}
   rule345 :: p -> p
rule345 = \ p
_self ->
     p
_self
   {-# INLINE rule346 #-}
   rule346 :: Int -> Int
rule346 = \ ((Int
_lhsIvisitnum) :: Int) ->
     Int
_lhsIvisitnum

-- Nonterminal -------------------------------------------------
-- wrapper
data Inh_Nonterminal  = Inh_Nonterminal { Inh_Nonterminal -> MyType -> MyAttributes
ain_Inh_Nonterminal :: (MyType -> MyAttributes), Inh_Nonterminal -> MyType -> MyAttributes
an_Inh_Nonterminal :: (MyType -> MyAttributes), Inh_Nonterminal
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
aroundMap_Inh_Nonterminal :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), Inh_Nonterminal -> MyType -> MyAttributes
asn_Inh_Nonterminal :: (MyType -> MyAttributes), Inh_Nonterminal -> AttrOrderMap
augM_Inh_Nonterminal :: (Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))), Inh_Nonterminal -> ContextMap
classContexts_Inh_Nonterminal :: (ContextMap), Inh_Nonterminal -> Map NontermIdent (Set NontermIdent)
closedHoNtDeps_Inh_Nonterminal :: (Map NontermIdent (Set NontermIdent)), Inh_Nonterminal -> Map NontermIdent (Set NontermIdent)
closedHoNtRevDeps_Inh_Nonterminal :: (Map NontermIdent (Set NontermIdent)), Inh_Nonterminal -> Map NontermIdent (Set NontermIdent)
closedNtDeps_Inh_Nonterminal :: (Map NontermIdent (Set NontermIdent)), Inh_Nonterminal -> Int
flab_Inh_Nonterminal :: (Int), Inh_Nonterminal -> FTY
fty_Inh_Nonterminal :: (FTY), Inh_Nonterminal -> FTY
ftyf_Inh_Nonterminal :: (FTY), Inh_Nonterminal -> HOMap
hoMapf_Inh_Nonterminal :: (HOMap), Inh_Nonterminal -> SF_P
lfpf_Inh_Nonterminal :: (SF_P), Inh_Nonterminal
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
mergeMap_Inh_Nonterminal :: (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))), Inh_Nonterminal -> NMP
nmp_Inh_Nonterminal :: (NMP), Inh_Nonterminal -> NMP_R
nmprf_Inh_Nonterminal :: (NMP_R), Inh_Nonterminal -> Int
olab_Inh_Nonterminal :: (Int), Inh_Nonterminal -> Options
options_Inh_Nonterminal :: (Options), Inh_Nonterminal -> PMP
pmpf_Inh_Nonterminal :: (PMP), Inh_Nonterminal -> PMP_R
pmprf_Inh_Nonterminal :: (PMP_R), Inh_Nonterminal -> [Edge]
res_ads_Inh_Nonterminal :: ([Edge]), Inh_Nonterminal -> Int
rulenumber_Inh_Nonterminal :: (Int), Inh_Nonterminal -> InterfaceRes
sched_Inh_Nonterminal :: (InterfaceRes), Inh_Nonterminal -> TDPRes
tdp_Inh_Nonterminal :: (TDPRes), Inh_Nonterminal -> IntMap Int
visMapf_Inh_Nonterminal :: (IMap.IntMap Int), Inh_Nonterminal -> Int
visitnum_Inh_Nonterminal :: (Int) }
data Syn_Nonterminal  = Syn_Nonterminal { Syn_Nonterminal -> [Edge]
ads_Syn_Nonterminal :: ([Edge]), Syn_Nonterminal -> A_P
ap_Syn_Nonterminal :: (A_P), Syn_Nonterminal -> ENonterminals
enonts_Syn_Nonterminal :: (ENonterminals), Syn_Nonterminal -> AttrOrderMap
fdps_Syn_Nonterminal :: (AttrOrderMap), Syn_Nonterminal -> FMap
fieldMap_Syn_Nonterminal :: (FMap), Syn_Nonterminal -> Int
flab_Syn_Nonterminal :: (Int), Syn_Nonterminal -> Map PLabel [(PLabel, FLabel)]
fsInP_Syn_Nonterminal :: (FsInP), Syn_Nonterminal -> FTY
fty_Syn_Nonterminal :: (FTY), Syn_Nonterminal -> Map Int Int
gen_Syn_Nonterminal :: (Map Int Int), Syn_Nonterminal -> HOMap
hoMap_Syn_Nonterminal :: (HOMap), Syn_Nonterminal -> Map NontermIdent (Map NontermIdent Type)
inhmap_Syn_Nonterminal :: (Map.Map NontermIdent Attributes), Syn_Nonterminal -> AI_N
inhs_Syn_Nonterminal :: (AI_N), Syn_Nonterminal -> Map Int [Int]
inss_Syn_Nonterminal :: (Map Int [Int]), Syn_Nonterminal -> SF_P
lfp_Syn_Nonterminal :: (SF_P), Syn_Nonterminal -> SF_P
lfpr_Syn_Nonterminal :: (SF_P), Syn_Nonterminal
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
localSigMap_Syn_Nonterminal :: (Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))), Syn_Nonterminal -> Map NontermIdent (Set NontermIdent)
ntDeps_Syn_Nonterminal :: (Map NontermIdent (Set NontermIdent)), Syn_Nonterminal -> Map NontermIdent (Set NontermIdent)
ntHoDeps_Syn_Nonterminal :: (Map NontermIdent (Set NontermIdent)), Syn_Nonterminal -> [Edge]
ofld_Syn_Nonterminal :: ([(Int, Int)]), Syn_Nonterminal -> Int
olab_Syn_Nonterminal :: (Int), Syn_Nonterminal -> PMP
pmp_Syn_Nonterminal :: (PMP), Syn_Nonterminal -> PMP_R
pmpr_Syn_Nonterminal :: (PMP_R), Syn_Nonterminal -> [PLabel]
ps_Syn_Nonterminal :: ([PLabel]), Syn_Nonterminal -> Map MyOccurrence NontermIdent
ruleMap_Syn_Nonterminal :: (Map.Map MyOccurrence Identifier), Syn_Nonterminal -> Int
rulenumber_Syn_Nonterminal :: (Int), Syn_Nonterminal -> Nonterminal
self_Syn_Nonterminal :: (Nonterminal), Syn_Nonterminal -> SF_P
sfp_Syn_Nonterminal :: (SF_P), Syn_Nonterminal -> Map NontermIdent (Map NontermIdent Type)
synmap_Syn_Nonterminal :: (Map.Map NontermIdent Attributes), Syn_Nonterminal -> AI_N
syns_Syn_Nonterminal :: (AS_N), Syn_Nonterminal -> IntMap Int
visMap_Syn_Nonterminal :: (IMap.IntMap Int), Syn_Nonterminal -> Int
visitnum_Syn_Nonterminal :: (Int) }
{-# INLINABLE wrap_Nonterminal #-}
wrap_Nonterminal :: T_Nonterminal  -> Inh_Nonterminal  -> (Syn_Nonterminal )
wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> Syn_Nonterminal
wrap_Nonterminal (T_Nonterminal Identity T_Nonterminal_s71
act) (Inh_Nonterminal MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Nonterminal_s71
sem <- Identity T_Nonterminal_s71
act
        let arg70 :: T_Nonterminal_vIn70
arg70 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> (MyType -> MyAttributes)
-> AttrOrderMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> InterfaceRes
-> TDPRes
-> IntMap Int
-> Int
-> T_Nonterminal_vIn70
T_Nonterminal_vIn70 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum
        (T_Nonterminal_vOut70 [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminal
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Nonterminal_s71 -> T_Nonterminal_v70
inv_Nonterminal_s71 T_Nonterminal_s71
sem T_Nonterminal_vIn70
arg70)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([Edge]
-> A_P
-> ENonterminals
-> AttrOrderMap
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Map MyOccurrence NontermIdent
-> Int
-> Nonterminal
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> IntMap Int
-> Int
-> Syn_Nonterminal
Syn_Nonterminal [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminal
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum)
   )

-- cata
{-# INLINE sem_Nonterminal #-}
sem_Nonterminal :: Nonterminal  -> T_Nonterminal 
sem_Nonterminal :: Nonterminal -> T_Nonterminal
sem_Nonterminal ( Nonterminal NontermIdent
nt_ [NontermIdent]
params_ Map NontermIdent Type
inh_ Map NontermIdent Type
syn_ Productions
prods_ ) = NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> Map NontermIdent Type
-> T_Productions
-> T_Nonterminal
sem_Nonterminal_Nonterminal NontermIdent
nt_ [NontermIdent]
params_ Map NontermIdent Type
inh_ Map NontermIdent Type
syn_ ( Productions -> T_Productions
sem_Productions Productions
prods_ )

-- semantic domain
newtype T_Nonterminal  = T_Nonterminal {
                                       T_Nonterminal -> Identity T_Nonterminal_s71
attach_T_Nonterminal :: Identity (T_Nonterminal_s71 )
                                       }
newtype T_Nonterminal_s71  = C_Nonterminal_s71 {
                                               T_Nonterminal_s71 -> T_Nonterminal_v70
inv_Nonterminal_s71 :: (T_Nonterminal_v70 )
                                               }
data T_Nonterminal_s72  = C_Nonterminal_s72
type T_Nonterminal_v70  = (T_Nonterminal_vIn70 ) -> (T_Nonterminal_vOut70 )
data T_Nonterminal_vIn70  = T_Nonterminal_vIn70 (MyType -> MyAttributes) (MyType -> MyAttributes) (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) (MyType -> MyAttributes) (Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))) (ContextMap) (Map NontermIdent (Set NontermIdent)) (Map NontermIdent (Set NontermIdent)) (Map NontermIdent (Set NontermIdent)) (Int) (FTY) (FTY) (HOMap) (SF_P) (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) (NMP) (NMP_R) (Int) (Options) (PMP) (PMP_R) ([Edge]) (Int) (InterfaceRes) (TDPRes) (IMap.IntMap Int) (Int)
data T_Nonterminal_vOut70  = T_Nonterminal_vOut70 ([Edge]) (A_P) (ENonterminals) (AttrOrderMap) (FMap) (Int) (FsInP) (FTY) (Map Int Int) (HOMap) (Map.Map NontermIdent Attributes) (AI_N) (Map Int [Int]) (SF_P) (SF_P) (Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))) (Map NontermIdent (Set NontermIdent)) (Map NontermIdent (Set NontermIdent)) ([(Int, Int)]) (Int) (PMP) (PMP_R) ([PLabel]) (Map.Map MyOccurrence Identifier) (Int) (Nonterminal) (SF_P) (Map.Map NontermIdent Attributes) (AS_N) (IMap.IntMap Int) (Int)
{-# NOINLINE sem_Nonterminal_Nonterminal #-}
sem_Nonterminal_Nonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_Productions  -> T_Nonterminal 
sem_Nonterminal_Nonterminal :: NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> Map NontermIdent Type
-> T_Productions
-> T_Nonterminal
sem_Nonterminal_Nonterminal NontermIdent
arg_nt_ [NontermIdent]
arg_params_ Map NontermIdent Type
arg_inh_ Map NontermIdent Type
arg_syn_ T_Productions
arg_prods_ = Identity T_Nonterminal_s71 -> T_Nonterminal
T_Nonterminal (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminal_s71
st71) where
   {-# NOINLINE st71 #-}
   st71 :: T_Nonterminal_s71
st71 = let
      v70 :: T_Nonterminal_v70 
      v70 :: T_Nonterminal_v70
v70 = \ (T_Nonterminal_vIn70 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _prodsX86 :: T_Productions_s86
_prodsX86 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s86
attach_T_Productions (T_Productions
arg_prods_))
         (T_Productions_vOut85 [Edge]
_prodsIads A_P
_prodsIap EProductions
_prodsIeprods Map NontermIdent (Set Dependency)
_prodsIfdps FMap
_prodsIfieldMap Int
_prodsIflab Map PLabel [(PLabel, FLabel)]
_prodsIfsInP FTY
_prodsIfty Map Int Int
_prodsIgen HOMap
_prodsIhoMap Map Int [Int]
_prodsIinss SF_P
_prodsIlfp SF_P
_prodsIlfpr Map NontermIdent (Map NontermIdent Type)
_prodsIlocalSigMap [Edge]
_prodsIofld Int
_prodsIolab PMP
_prodsIpmp PMP_R
_prodsIpmpr [PLabel]
_prodsIps Set NontermIdent
_prodsIrefHoNts Set NontermIdent
_prodsIrefNts Map MyOccurrence NontermIdent
_prodsIruleMap Int
_prodsIrulenumber Productions
_prodsIself SF_P
_prodsIsfp Int
_prodsIvisitnum) = T_Productions_s86 -> T_Productions_v85
inv_Productions_s86 T_Productions_s86
_prodsX86 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent (Map NontermIdent [Expression])
-> (MyType -> MyAttributes)
-> Map NontermIdent (Set Dependency)
-> MyType
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> [MySegment]
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> TDPRes
-> IntMap Int
-> Int
-> T_Productions_vIn85
T_Productions_vIn85 MyType -> MyAttributes
_prodsOain MyType -> MyAttributes
_prodsOan Map NontermIdent (Map NontermIdent [Expression])
_prodsOaroundMap MyType -> MyAttributes
_prodsOasn Map NontermIdent (Set Dependency)
_prodsOaugM MyType
_prodsOdty Int
_prodsOflab FTY
_prodsOfty FTY
_prodsOftyf HOMap
_prodsOhoMapf SF_P
_prodsOlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_prodsOmergeMap [MySegment]
_prodsOmysegments NMP
_prodsOnmp NMP_R
_prodsOnmprf Int
_prodsOolab Options
_prodsOoptions PMP
_prodsOpmpf PMP_R
_prodsOpmprf [Edge]
_prodsOres_ads Int
_prodsOrulenumber TDPRes
_prodsOtdp IntMap Int
_prodsOvisMapf Int
_prodsOvisitnum)
         _lhsOntDeps :: Map NontermIdent (Set NontermIdent)
         _lhsOntDeps :: Map NontermIdent (Set NontermIdent)
_lhsOntDeps = forall {k}. Set NontermIdent -> k -> Map k (Set NontermIdent)
rule347 Set NontermIdent
_prodsIrefNts NontermIdent
arg_nt_
         _lhsOntHoDeps :: Map NontermIdent (Set NontermIdent)
         _lhsOntHoDeps :: Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps = forall {k}. Set NontermIdent -> k -> Map k (Set NontermIdent)
rule348 Set NontermIdent
_prodsIrefHoNts NontermIdent
arg_nt_
         _closedNtDeps :: Set NontermIdent
_closedNtDeps = Map NontermIdent (Set NontermIdent)
-> NontermIdent -> Set NontermIdent
rule349 Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps NontermIdent
arg_nt_
         _closedHoNtDeps :: Set NontermIdent
_closedHoNtDeps = Map NontermIdent (Set NontermIdent)
-> NontermIdent -> Set NontermIdent
rule350 Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps NontermIdent
arg_nt_
         _closedHoNtRevDeps :: Set NontermIdent
_closedHoNtRevDeps = Map NontermIdent (Set NontermIdent)
-> NontermIdent -> Set NontermIdent
rule351 Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps NontermIdent
arg_nt_
         _recursive :: Bool
_recursive = Set NontermIdent -> NontermIdent -> Bool
rule352 Set NontermIdent
_closedNtDeps NontermIdent
arg_nt_
         _nontrivAcyc :: Bool
_nontrivAcyc = Set NontermIdent -> NontermIdent -> Bool
rule353 Set NontermIdent
_closedHoNtDeps NontermIdent
arg_nt_
         _hoInfo :: HigherOrderInfo
_hoInfo = Set NontermIdent -> Set NontermIdent -> Bool -> HigherOrderInfo
rule354 Set NontermIdent
_closedHoNtDeps Set NontermIdent
_closedHoNtRevDeps Bool
_nontrivAcyc
         _classContexts :: [(NontermIdent, [FLabel])]
_classContexts = ContextMap -> NontermIdent -> [(NontermIdent, [FLabel])]
rule355 ContextMap
_lhsIclassContexts NontermIdent
arg_nt_
         _aroundMap :: Map NontermIdent (Map NontermIdent [Expression])
_aroundMap = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> NontermIdent -> Map NontermIdent (Map NontermIdent [Expression])
rule356 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap NontermIdent
arg_nt_
         _mergeMap :: Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_mergeMap = Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> NontermIdent
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
rule357 Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NontermIdent
arg_nt_
         _lhsOinhmap :: Map.Map NontermIdent Attributes
         _lhsOinhmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap = forall {a} {k}. a -> k -> Map k a
rule358 Map NontermIdent Type
arg_inh_ NontermIdent
arg_nt_
         _lhsOsynmap :: Map.Map NontermIdent Attributes
         _lhsOsynmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap = forall k a. k -> a -> Map k a
rule359 NontermIdent
arg_nt_ Map NontermIdent Type
arg_syn_
         _lhsOlocalSigMap :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap = forall {k}.
Map NontermIdent (Map NontermIdent Type)
-> k -> Map k (Map NontermIdent (Map NontermIdent Type))
rule360 Map NontermIdent (Map NontermIdent Type)
_prodsIlocalSigMap NontermIdent
arg_nt_
         _lhsOinhs :: AI_N
         _lhsOinhs :: AI_N
_lhsOinhs = Map NontermIdent Type -> NontermIdent -> AI_N
rule361 Map NontermIdent Type
arg_inh_ NontermIdent
arg_nt_
         _lhsOsyns :: AS_N
         _lhsOsyns :: AI_N
_lhsOsyns = NontermIdent -> Map NontermIdent Type -> AI_N
rule362 NontermIdent
arg_nt_ Map NontermIdent Type
arg_syn_
         _prodsOaugM :: Map NontermIdent (Set Dependency)
_prodsOaugM = AttrOrderMap -> NontermIdent -> Map NontermIdent (Set Dependency)
rule363 AttrOrderMap
_lhsIaugM NontermIdent
arg_nt_
         _dty :: MyType
_dty = NontermIdent -> MyType
rule364 NontermIdent
arg_nt_
         _lhsOfdps :: AttrOrderMap
         _lhsOfdps :: AttrOrderMap
_lhsOfdps = forall {k}.
Map NontermIdent (Set Dependency)
-> k -> Map k (Map NontermIdent (Set Dependency))
rule365 Map NontermIdent (Set Dependency)
_prodsIfdps NontermIdent
arg_nt_
         _initial :: Int
_initial = Int -> Int
rule366 Int
_lhsIvisitnum
         _vnums :: [Int]
_vnums = forall {b}. Int -> [b] -> [Int]
rule367 Int
_initial [CSegment]
_segments
         _initialVisit :: [Int]
_initialVisit = forall a. a -> a
rule368 [Int]
_vnums
         _nextVis :: Map Int StateCtx
_nextVis = Int -> [Int] -> Map Int StateCtx
rule369 Int
_initial [Int]
_vnums
         _prevVis :: Map Int StateCtx
_prevVis = Int -> [Int] -> Map Int StateCtx
rule370 Int
_initial [Int]
_vnums
         _visMap :: IntMap Int
_visMap = Int -> [MySegment] -> IntMap Int
rule371 Int
_initial [MySegment]
_mysegments
         _lhsOenonts :: ENonterminals
         _lhsOenonts :: ENonterminals
_lhsOenonts = [(NontermIdent, [FLabel])]
-> HigherOrderInfo
-> Int
-> [Int]
-> Map Int StateCtx
-> Map Int StateCtx
-> EProductions
-> Bool
-> NontermIdent
-> [NontermIdent]
-> ENonterminals
rule372 [(NontermIdent, [FLabel])]
_classContexts HigherOrderInfo
_hoInfo Int
_initial [Int]
_initialVisit Map Int StateCtx
_nextVis Map Int StateCtx
_prevVis EProductions
_prodsIeprods Bool
_recursive NontermIdent
arg_nt_ [NontermIdent]
arg_params_
         _assigned :: IntMap [Int]
_assigned = InterfaceRes -> NontermIdent -> IntMap [Int]
rule373 InterfaceRes
_lhsIsched NontermIdent
arg_nt_
         _mx :: Int
_mx = forall {b}. IntMap b -> InterfaceRes -> Int
rule374 IntMap [Int]
_assigned InterfaceRes
_lhsIsched
         _mysegments :: [MySegment]
_mysegments = IntMap [Int] -> Int -> [MySegment]
rule375 IntMap [Int]
_assigned Int
_mx
         _segments :: [CSegment]
_segments = NMP -> [MySegment] -> [CSegment]
rule376 NMP
_lhsInmp [MySegment]
_mysegments
         _lhsOads :: [Edge]
         _lhsOads :: [Edge]
_lhsOads = [Edge] -> [Edge]
rule377 [Edge]
_prodsIads
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P
rule378 A_P
_prodsIap
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = FMap -> FMap
rule379 FMap
_prodsIfieldMap
         _lhsOfsInP :: FsInP
         _lhsOfsInP :: Map PLabel [(PLabel, FLabel)]
_lhsOfsInP = Map PLabel [(PLabel, FLabel)] -> Map PLabel [(PLabel, FLabel)]
rule380 Map PLabel [(PLabel, FLabel)]
_prodsIfsInP
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = FTY -> FTY
rule381 FTY
_prodsIfty
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int
rule382 Map Int Int
_prodsIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = HOMap -> HOMap
rule383 HOMap
_prodsIhoMap
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int]
rule384 Map Int [Int]
_prodsIinss
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = SF_P -> SF_P
rule385 SF_P
_prodsIlfp
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = SF_P -> SF_P
rule386 SF_P
_prodsIlfpr
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge]
rule387 [Edge]
_prodsIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP
rule388 PMP
_prodsIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R
rule389 PMP_R
_prodsIpmpr
         _lhsOps :: [PLabel]
         _lhsOps :: [PLabel]
_lhsOps = [PLabel] -> [PLabel]
rule390 [PLabel]
_prodsIps
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule391 Map MyOccurrence NontermIdent
_prodsIruleMap
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = SF_P -> SF_P
rule392 SF_P
_prodsIsfp
         _lhsOvisMap :: IMap.IntMap Int
         _lhsOvisMap :: IntMap Int
_lhsOvisMap = forall a. a -> a
rule393 IntMap Int
_visMap
         _self :: Nonterminal
_self = Productions
-> Map NontermIdent Type
-> NontermIdent
-> [NontermIdent]
-> Map NontermIdent Type
-> Nonterminal
rule394 Productions
_prodsIself Map NontermIdent Type
arg_inh_ NontermIdent
arg_nt_ [NontermIdent]
arg_params_ Map NontermIdent Type
arg_syn_
         _lhsOself :: Nonterminal
         _lhsOself :: Nonterminal
_lhsOself = forall a. a -> a
rule395 Nonterminal
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule396 Int
_prodsIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule397 Int
_prodsIolab
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule398 Int
_prodsIrulenumber
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule399 Int
_prodsIvisitnum
         _prodsOain :: MyType -> MyAttributes
_prodsOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule400 MyType -> MyAttributes
_lhsIain
         _prodsOan :: MyType -> MyAttributes
_prodsOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule401 MyType -> MyAttributes
_lhsIan
         _prodsOaroundMap :: Map NontermIdent (Map NontermIdent [Expression])
_prodsOaroundMap = forall a. a -> a
rule402 Map NontermIdent (Map NontermIdent [Expression])
_aroundMap
         _prodsOasn :: MyType -> MyAttributes
_prodsOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule403 MyType -> MyAttributes
_lhsIasn
         _prodsOdty :: MyType
_prodsOdty = forall a. a -> a
rule404 MyType
_dty
         _prodsOflab :: Int
_prodsOflab = Int -> Int
rule405 Int
_lhsIflab
         _prodsOfty :: FTY
_prodsOfty = FTY -> FTY
rule406 FTY
_lhsIfty
         _prodsOftyf :: FTY
_prodsOftyf = FTY -> FTY
rule407 FTY
_lhsIftyf
         _prodsOhoMapf :: HOMap
_prodsOhoMapf = HOMap -> HOMap
rule408 HOMap
_lhsIhoMapf
         _prodsOlfpf :: SF_P
_prodsOlfpf = SF_P -> SF_P
rule409 SF_P
_lhsIlfpf
         _prodsOmergeMap :: Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_prodsOmergeMap = forall a. a -> a
rule410 Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_mergeMap
         _prodsOmysegments :: [MySegment]
_prodsOmysegments = forall a. a -> a
rule411 [MySegment]
_mysegments
         _prodsOnmp :: NMP
_prodsOnmp = NMP -> NMP
rule412 NMP
_lhsInmp
         _prodsOnmprf :: NMP_R
_prodsOnmprf = NMP_R -> NMP_R
rule413 NMP_R
_lhsInmprf
         _prodsOolab :: Int
_prodsOolab = Int -> Int
rule414 Int
_lhsIolab
         _prodsOoptions :: Options
_prodsOoptions = Options -> Options
rule415 Options
_lhsIoptions
         _prodsOpmpf :: PMP
_prodsOpmpf = PMP -> PMP
rule416 PMP
_lhsIpmpf
         _prodsOpmprf :: PMP_R
_prodsOpmprf = PMP_R -> PMP_R
rule417 PMP_R
_lhsIpmprf
         _prodsOres_ads :: [Edge]
_prodsOres_ads = [Edge] -> [Edge]
rule418 [Edge]
_lhsIres_ads
         _prodsOrulenumber :: Int
_prodsOrulenumber = Int -> Int
rule419 Int
_lhsIrulenumber
         _prodsOtdp :: TDPRes
_prodsOtdp = TDPRes -> TDPRes
rule420 TDPRes
_lhsItdp
         _prodsOvisMapf :: IntMap Int
_prodsOvisMapf = IntMap Int -> IntMap Int
rule421 IntMap Int
_lhsIvisMapf
         _prodsOvisitnum :: Int
_prodsOvisitnum = Int -> Int
rule422 Int
_lhsIvisitnum
         __result_ :: T_Nonterminal_vOut70
__result_ = [Edge]
-> A_P
-> ENonterminals
-> AttrOrderMap
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Map MyOccurrence NontermIdent
-> Int
-> Nonterminal
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> IntMap Int
-> Int
-> T_Nonterminal_vOut70
T_Nonterminal_vOut70 [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminal
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum
         in T_Nonterminal_vOut70
__result_ )
     in T_Nonterminal_v70 -> T_Nonterminal_s71
C_Nonterminal_s71 T_Nonterminal_v70
v70
   {-# INLINE rule347 #-}
   {-# LINE 16 "src-ag/ExecutionPlanCommon.ag" #-}
   rule347 = \ ((_prodsIrefNts) :: Set NontermIdent) nt_ ->
                            {-# LINE 16 "src-ag/ExecutionPlanCommon.ag" #-}
                            Map.singleton nt_ _prodsIrefNts
                            {-# LINE 3495 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule348 #-}
   {-# LINE 17 "src-ag/ExecutionPlanCommon.ag" #-}
   rule348 = \ ((_prodsIrefHoNts) :: Set NontermIdent) nt_ ->
                            {-# LINE 17 "src-ag/ExecutionPlanCommon.ag" #-}
                            Map.singleton nt_ _prodsIrefHoNts
                            {-# LINE 3501 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule349 #-}
   {-# LINE 19 "src-ag/ExecutionPlanCommon.ag" #-}
   rule349 = \ ((_lhsIclosedNtDeps) :: Map NontermIdent (Set NontermIdent)) nt_ ->
                            {-# LINE 19 "src-ag/ExecutionPlanCommon.ag" #-}
                            Map.findWithDefault Set.empty nt_ _lhsIclosedNtDeps
                            {-# LINE 3507 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule350 #-}
   {-# LINE 20 "src-ag/ExecutionPlanCommon.ag" #-}
   rule350 = \ ((_lhsIclosedHoNtDeps) :: Map NontermIdent (Set NontermIdent)) nt_ ->
                            {-# LINE 20 "src-ag/ExecutionPlanCommon.ag" #-}
                            Map.findWithDefault Set.empty nt_ _lhsIclosedHoNtDeps
                            {-# LINE 3513 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule351 #-}
   {-# LINE 21 "src-ag/ExecutionPlanCommon.ag" #-}
   rule351 = \ ((_lhsIclosedHoNtRevDeps) :: Map NontermIdent (Set NontermIdent)) nt_ ->
                            {-# LINE 21 "src-ag/ExecutionPlanCommon.ag" #-}
                            Map.findWithDefault Set.empty nt_ _lhsIclosedHoNtRevDeps
                            {-# LINE 3519 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule352 #-}
   {-# LINE 23 "src-ag/ExecutionPlanCommon.ag" #-}
   rule352 = \ _closedNtDeps nt_ ->
                            {-# LINE 23 "src-ag/ExecutionPlanCommon.ag" #-}
                            nt_ `Set.member` _closedNtDeps
                            {-# LINE 3525 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule353 #-}
   {-# LINE 24 "src-ag/ExecutionPlanCommon.ag" #-}
   rule353 = \ _closedHoNtDeps nt_ ->
                            {-# LINE 24 "src-ag/ExecutionPlanCommon.ag" #-}
                            nt_ `Set.member` _closedHoNtDeps
                            {-# LINE 3531 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule354 #-}
   {-# LINE 25 "src-ag/ExecutionPlanCommon.ag" #-}
   rule354 = \ _closedHoNtDeps _closedHoNtRevDeps _nontrivAcyc ->
                            {-# LINE 25 "src-ag/ExecutionPlanCommon.ag" #-}
                            HigherOrderInfo { hoNtDeps            = _closedHoNtDeps
                                            , hoNtRevDeps         = _closedHoNtRevDeps
                                            , hoAcyclic           = _nontrivAcyc
                                            }
                            {-# LINE 3540 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule355 #-}
   {-# LINE 54 "src-ag/ExecutionPlanCommon.ag" #-}
   rule355 = \ ((_lhsIclassContexts) :: ContextMap) nt_ ->
                        {-# LINE 54 "src-ag/ExecutionPlanCommon.ag" #-}
                        Map.findWithDefault [] nt_ _lhsIclassContexts
                        {-# LINE 3546 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule356 #-}
   {-# LINE 88 "src-ag/ExecutionPlanCommon.ag" #-}
   rule356 = \ ((_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) nt_ ->
                                                 {-# LINE 88 "src-ag/ExecutionPlanCommon.ag" #-}
                                                 Map.findWithDefault Map.empty nt_ _lhsIaroundMap
                                                 {-# LINE 3552 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule357 #-}
   {-# LINE 113 "src-ag/ExecutionPlanCommon.ag" #-}
   rule357 = \ ((_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) nt_ ->
                                                {-# LINE 113 "src-ag/ExecutionPlanCommon.ag" #-}
                                                Map.findWithDefault Map.empty nt_ _lhsImergeMap
                                                {-# LINE 3558 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule358 #-}
   {-# LINE 149 "src-ag/ExecutionPlanCommon.ag" #-}
   rule358 = \ inh_ nt_ ->
                               {-# LINE 149 "src-ag/ExecutionPlanCommon.ag" #-}
                               Map.singleton nt_ inh_
                               {-# LINE 3564 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule359 #-}
   {-# LINE 150 "src-ag/ExecutionPlanCommon.ag" #-}
   rule359 = \ nt_ syn_ ->
                               {-# LINE 150 "src-ag/ExecutionPlanCommon.ag" #-}
                               Map.singleton nt_ syn_
                               {-# LINE 3570 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule360 #-}
   {-# LINE 159 "src-ag/ExecutionPlanCommon.ag" #-}
   rule360 = \ ((_prodsIlocalSigMap) :: Map.Map ConstructorIdent (Map.Map Identifier Type)) nt_ ->
                                                   {-# LINE 159 "src-ag/ExecutionPlanCommon.ag" #-}
                                                   Map.singleton nt_ _prodsIlocalSigMap
                                                   {-# LINE 3576 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule361 #-}
   {-# LINE 65 "src-ag/LOAG/Prepare.ag" #-}
   rule361 = \ inh_ nt_ ->
                 {-# LINE 65 "src-ag/LOAG/Prepare.ag" #-}
                 let dty = TyData (getName nt_)
                  in Map.singleton dty (toMyAttr Inh dty inh_)
                 {-# LINE 3583 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule362 #-}
   {-# LINE 67 "src-ag/LOAG/Prepare.ag" #-}
   rule362 = \ nt_ syn_ ->
                 {-# LINE 67 "src-ag/LOAG/Prepare.ag" #-}
                 let dty = TyData (getName nt_)
                  in Map.singleton dty (toMyAttr Syn dty syn_)
                 {-# LINE 3590 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule363 #-}
   {-# LINE 69 "src-ag/LOAG/Prepare.ag" #-}
   rule363 = \ ((_lhsIaugM) :: Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))) nt_ ->
                   {-# LINE 69 "src-ag/LOAG/Prepare.ag" #-}
                   case Map.lookup nt_ _lhsIaugM of
                      Nothing -> Map.empty
                      Just a  -> a
                   {-# LINE 3598 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule364 #-}
   {-# LINE 131 "src-ag/LOAG/Prepare.ag" #-}
   rule364 = \ nt_ ->
                 {-# LINE 131 "src-ag/LOAG/Prepare.ag" #-}
                 TyData (getName nt_)
                 {-# LINE 3604 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule365 #-}
   {-# LINE 82 "src-ag/LOAG/Order.ag" #-}
   rule365 = \ ((_prodsIfdps) :: Map.Map ConstructorIdent (Set Dependency)) nt_ ->
                    {-# LINE 82 "src-ag/LOAG/Order.ag" #-}
                    Map.singleton nt_ _prodsIfdps
                    {-# LINE 3610 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule366 #-}
   {-# LINE 138 "src-ag/LOAG/Order.ag" #-}
   rule366 = \ ((_lhsIvisitnum) :: Int) ->
                        {-# LINE 138 "src-ag/LOAG/Order.ag" #-}
                        _lhsIvisitnum
                        {-# LINE 3616 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule367 #-}
   {-# LINE 139 "src-ag/LOAG/Order.ag" #-}
   rule367 = \ _initial _segments ->
                        {-# LINE 139 "src-ag/LOAG/Order.ag" #-}
                        zipWith const [_initial    ..] _segments
                        {-# LINE 3622 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule368 #-}
   {-# LINE 140 "src-ag/LOAG/Order.ag" #-}
   rule368 = \ _vnums ->
                             {-# LINE 140 "src-ag/LOAG/Order.ag" #-}
                             _vnums
                             {-# LINE 3628 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule369 #-}
   {-# LINE 141 "src-ag/LOAG/Order.ag" #-}
   rule369 = \ _initial _vnums ->
                        {-# LINE 141 "src-ag/LOAG/Order.ag" #-}
                        Map.fromList $ (_initial     + length _vnums, NoneVis)
                                     : [(v, OneVis v) | v <- _vnums ]
                        {-# LINE 3635 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule370 #-}
   {-# LINE 143 "src-ag/LOAG/Order.ag" #-}
   rule370 = \ _initial _vnums ->
                        {-# LINE 143 "src-ag/LOAG/Order.ag" #-}
                        Map.fromList $ (_initial    , NoneVis)
                                     : [(v+1, OneVis v) | v <- _vnums ]
                        {-# LINE 3642 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule371 #-}
   {-# LINE 145 "src-ag/LOAG/Order.ag" #-}
   rule371 = \ _initial _mysegments ->
                        {-# LINE 145 "src-ag/LOAG/Order.ag" #-}
                        let op vnr (MySegment visnr ins syns _ _) =
                              IMap.fromList $ zip syns (repeat vnr)
                         in IMap.unions $ zipWith op [_initial    ..] _mysegments
                        {-# LINE 3650 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule372 #-}
   {-# LINE 148 "src-ag/LOAG/Order.ag" #-}
   rule372 = \ _classContexts _hoInfo _initial _initialVisit _nextVis _prevVis ((_prodsIeprods) :: EProductions) _recursive nt_ params_ ->
                       {-# LINE 148 "src-ag/LOAG/Order.ag" #-}
                       [ENonterminal
                          nt_
                          params_
                          _classContexts
                          _initial
                          _initialVisit
                          _nextVis
                          _prevVis
                          _prodsIeprods
                          _recursive
                          _hoInfo     ]
                       {-# LINE 3666 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule373 #-}
   {-# LINE 322 "src-ag/LOAG/Order.ag" #-}
   rule373 = \ ((_lhsIsched) :: InterfaceRes) nt_ ->
                         {-# LINE 322 "src-ag/LOAG/Order.ag" #-}
                         findWithErr _lhsIsched "could not const. interfaces"
                              (getName nt_)
                         {-# LINE 3673 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule374 #-}
   {-# LINE 324 "src-ag/LOAG/Order.ag" #-}
   rule374 = \ _assigned ((_lhsIsched) :: InterfaceRes) ->
                         {-# LINE 324 "src-ag/LOAG/Order.ag" #-}
                         if Map.null _lhsIsched
                          then 0
                          else let mx = fst $ IMap.findMax _assigned     in
                                if even mx then mx else mx + 1
                         {-# LINE 3682 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule375 #-}
   {-# LINE 329 "src-ag/LOAG/Order.ag" #-}
   rule375 = \ _assigned _mx ->
              {-# LINE 329 "src-ag/LOAG/Order.ag" #-}
              map (\i -> MySegment ((_mx     - i) `div` 2)
                          (maybe [] id $ IMap.lookup i _assigned    )
                          (maybe [] id $ IMap.lookup (i-1) _assigned    )
                              Nothing Nothing)
                   [_mx    ,_mx    -2 .. 2]
              {-# LINE 3692 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule376 #-}
   {-# LINE 335 "src-ag/LOAG/Order.ag" #-}
   rule376 = \ ((_lhsInmp) :: NMP) _mysegments ->
              {-# LINE 335 "src-ag/LOAG/Order.ag" #-}
              map (\(MySegment visnr is ss _ _) ->
                      CSegment (Map.unions $ map (vertexToAttr _lhsInmp) is)
                               (Map.unions $ map (vertexToAttr _lhsInmp) ss))
                  _mysegments
              {-# LINE 3701 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule377 #-}
   rule377 = \ ((_prodsIads) :: [Edge]) ->
     _prodsIads
   {-# INLINE rule378 #-}
   rule378 = \ ((_prodsIap) :: A_P) ->
     _prodsIap
   {-# INLINE rule379 #-}
   rule379 = \ ((_prodsIfieldMap) :: FMap) ->
     _prodsIfieldMap
   {-# INLINE rule380 #-}
   rule380 = \ ((_prodsIfsInP) :: FsInP) ->
     _prodsIfsInP
   {-# INLINE rule381 #-}
   rule381 = \ ((_prodsIfty) :: FTY) ->
     _prodsIfty
   {-# INLINE rule382 #-}
   rule382 = \ ((_prodsIgen) :: Map Int Int) ->
     _prodsIgen
   {-# INLINE rule383 #-}
   rule383 = \ ((_prodsIhoMap) :: HOMap) ->
     _prodsIhoMap
   {-# INLINE rule384 #-}
   rule384 = \ ((_prodsIinss) :: Map Int [Int]) ->
     _prodsIinss
   {-# INLINE rule385 #-}
   rule385 = \ ((_prodsIlfp) :: SF_P) ->
     _prodsIlfp
   {-# INLINE rule386 #-}
   rule386 = \ ((_prodsIlfpr) :: SF_P) ->
     _prodsIlfpr
   {-# INLINE rule387 #-}
   rule387 = \ ((_prodsIofld) :: [(Int, Int)]) ->
     _prodsIofld
   {-# INLINE rule388 #-}
   rule388 = \ ((_prodsIpmp) :: PMP) ->
     _prodsIpmp
   {-# INLINE rule389 #-}
   rule389 = \ ((_prodsIpmpr) :: PMP_R) ->
     _prodsIpmpr
   {-# INLINE rule390 #-}
   rule390 = \ ((_prodsIps) :: [PLabel]) ->
     _prodsIps
   {-# INLINE rule391 #-}
   rule391 = \ ((_prodsIruleMap) :: Map.Map MyOccurrence Identifier) ->
     _prodsIruleMap
   {-# INLINE rule392 #-}
   rule392 = \ ((_prodsIsfp) :: SF_P) ->
     _prodsIsfp
   {-# INLINE rule393 #-}
   rule393 = \ _visMap ->
     _visMap
   {-# INLINE rule394 #-}
   rule394 = \ ((_prodsIself) :: Productions) inh_ nt_ params_ syn_ ->
     Nonterminal nt_ params_ inh_ syn_ _prodsIself
   {-# INLINE rule395 #-}
   rule395 = \ _self ->
     _self
   {-# INLINE rule396 #-}
   rule396 = \ ((_prodsIflab) :: Int) ->
     _prodsIflab
   {-# INLINE rule397 #-}
   rule397 = \ ((_prodsIolab) :: Int) ->
     _prodsIolab
   {-# INLINE rule398 #-}
   rule398 = \ ((_prodsIrulenumber) :: Int) ->
     _prodsIrulenumber
   {-# INLINE rule399 #-}
   rule399 = \ ((_prodsIvisitnum) :: Int) ->
     _prodsIvisitnum
   {-# INLINE rule400 #-}
   rule400 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule401 #-}
   rule401 = \ ((_lhsIan) :: MyType -> MyAttributes) ->
     _lhsIan
   {-# INLINE rule402 #-}
   rule402 = \ _aroundMap ->
     _aroundMap
   {-# INLINE rule403 #-}
   rule403 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule404 #-}
   rule404 = \ _dty ->
     _dty
   {-# INLINE rule405 #-}
   rule405 = \ ((_lhsIflab) :: Int) ->
     _lhsIflab
   {-# INLINE rule406 #-}
   rule406 = \ ((_lhsIfty) :: FTY) ->
     _lhsIfty
   {-# INLINE rule407 #-}
   rule407 = \ ((_lhsIftyf) :: FTY) ->
     _lhsIftyf
   {-# INLINE rule408 #-}
   rule408 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule409 #-}
   rule409 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule410 #-}
   rule410 = \ _mergeMap ->
     _mergeMap
   {-# INLINE rule411 #-}
   rule411 = \ _mysegments ->
     _mysegments
   {-# INLINE rule412 #-}
   rule412 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule413 #-}
   rule413 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule414 #-}
   rule414 = \ ((_lhsIolab) :: Int) ->
     _lhsIolab
   {-# INLINE rule415 #-}
   rule415 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule416 #-}
   rule416 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule417 #-}
   rule417 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule418 #-}
   rule418 = \ ((_lhsIres_ads) :: [Edge]) ->
     _lhsIres_ads
   {-# INLINE rule419 #-}
   rule419 = \ ((_lhsIrulenumber) :: Int) ->
     _lhsIrulenumber
   {-# INLINE rule420 #-}
   rule420 = \ ((_lhsItdp) :: TDPRes) ->
     _lhsItdp
   {-# INLINE rule421 #-}
   rule421 = \ ((_lhsIvisMapf) :: IMap.IntMap Int) ->
     _lhsIvisMapf
   {-# INLINE rule422 #-}
   rule422 = \ ((_lhsIvisitnum) :: Int) ->
     _lhsIvisitnum

-- Nonterminals ------------------------------------------------
-- wrapper
data Inh_Nonterminals  = Inh_Nonterminals { Inh_Nonterminals -> MyType -> MyAttributes
ain_Inh_Nonterminals :: (MyType -> MyAttributes), Inh_Nonterminals -> MyType -> MyAttributes
an_Inh_Nonterminals :: (MyType -> MyAttributes), Inh_Nonterminals
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
aroundMap_Inh_Nonterminals :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), Inh_Nonterminals -> MyType -> MyAttributes
asn_Inh_Nonterminals :: (MyType -> MyAttributes), Inh_Nonterminals -> AttrOrderMap
augM_Inh_Nonterminals :: (Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))), Inh_Nonterminals -> ContextMap
classContexts_Inh_Nonterminals :: (ContextMap), Inh_Nonterminals -> Map NontermIdent (Set NontermIdent)
closedHoNtDeps_Inh_Nonterminals :: (Map NontermIdent (Set NontermIdent)), Inh_Nonterminals -> Map NontermIdent (Set NontermIdent)
closedHoNtRevDeps_Inh_Nonterminals :: (Map NontermIdent (Set NontermIdent)), Inh_Nonterminals -> Map NontermIdent (Set NontermIdent)
closedNtDeps_Inh_Nonterminals :: (Map NontermIdent (Set NontermIdent)), Inh_Nonterminals -> Int
flab_Inh_Nonterminals :: (Int), Inh_Nonterminals -> FTY
fty_Inh_Nonterminals :: (FTY), Inh_Nonterminals -> FTY
ftyf_Inh_Nonterminals :: (FTY), Inh_Nonterminals -> HOMap
hoMapf_Inh_Nonterminals :: (HOMap), Inh_Nonterminals -> SF_P
lfpf_Inh_Nonterminals :: (SF_P), Inh_Nonterminals
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
mergeMap_Inh_Nonterminals :: (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))), Inh_Nonterminals -> NMP
nmp_Inh_Nonterminals :: (NMP), Inh_Nonterminals -> NMP_R
nmprf_Inh_Nonterminals :: (NMP_R), Inh_Nonterminals -> Int
olab_Inh_Nonterminals :: (Int), Inh_Nonterminals -> Options
options_Inh_Nonterminals :: (Options), Inh_Nonterminals -> PMP
pmpf_Inh_Nonterminals :: (PMP), Inh_Nonterminals -> PMP_R
pmprf_Inh_Nonterminals :: (PMP_R), Inh_Nonterminals -> [Edge]
res_ads_Inh_Nonterminals :: ([Edge]), Inh_Nonterminals -> Int
rulenumber_Inh_Nonterminals :: (Int), Inh_Nonterminals -> InterfaceRes
sched_Inh_Nonterminals :: (InterfaceRes), Inh_Nonterminals -> TDPRes
tdp_Inh_Nonterminals :: (TDPRes), Inh_Nonterminals -> IntMap Int
visMapf_Inh_Nonterminals :: (IMap.IntMap Int), Inh_Nonterminals -> Int
visitnum_Inh_Nonterminals :: (Int) }
data Syn_Nonterminals  = Syn_Nonterminals { Syn_Nonterminals -> [Edge]
ads_Syn_Nonterminals :: ([Edge]), Syn_Nonterminals -> A_P
ap_Syn_Nonterminals :: (A_P), Syn_Nonterminals -> ENonterminals
enonts_Syn_Nonterminals :: (ENonterminals), Syn_Nonterminals -> AttrOrderMap
fdps_Syn_Nonterminals :: (AttrOrderMap), Syn_Nonterminals -> FMap
fieldMap_Syn_Nonterminals :: (FMap), Syn_Nonterminals -> Int
flab_Syn_Nonterminals :: (Int), Syn_Nonterminals -> Map PLabel [(PLabel, FLabel)]
fsInP_Syn_Nonterminals :: (FsInP), Syn_Nonterminals -> FTY
fty_Syn_Nonterminals :: (FTY), Syn_Nonterminals -> Map Int Int
gen_Syn_Nonterminals :: (Map Int Int), Syn_Nonterminals -> HOMap
hoMap_Syn_Nonterminals :: (HOMap), Syn_Nonterminals -> Map NontermIdent (Map NontermIdent Type)
inhmap_Syn_Nonterminals :: (Map.Map NontermIdent Attributes), Syn_Nonterminals -> AI_N
inhs_Syn_Nonterminals :: (AI_N), Syn_Nonterminals -> Map Int [Int]
inss_Syn_Nonterminals :: (Map Int [Int]), Syn_Nonterminals -> SF_P
lfp_Syn_Nonterminals :: (SF_P), Syn_Nonterminals -> SF_P
lfpr_Syn_Nonterminals :: (SF_P), Syn_Nonterminals
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
localSigMap_Syn_Nonterminals :: (Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))), Syn_Nonterminals -> Map NontermIdent (Set NontermIdent)
ntDeps_Syn_Nonterminals :: (Map NontermIdent (Set NontermIdent)), Syn_Nonterminals -> Map NontermIdent (Set NontermIdent)
ntHoDeps_Syn_Nonterminals :: (Map NontermIdent (Set NontermIdent)), Syn_Nonterminals -> [Edge]
ofld_Syn_Nonterminals :: ([(Int, Int)]), Syn_Nonterminals -> Int
olab_Syn_Nonterminals :: (Int), Syn_Nonterminals -> PMP
pmp_Syn_Nonterminals :: (PMP), Syn_Nonterminals -> PMP_R
pmpr_Syn_Nonterminals :: (PMP_R), Syn_Nonterminals -> [PLabel]
ps_Syn_Nonterminals :: ([PLabel]), Syn_Nonterminals -> Map MyOccurrence NontermIdent
ruleMap_Syn_Nonterminals :: (Map.Map MyOccurrence Identifier), Syn_Nonterminals -> Int
rulenumber_Syn_Nonterminals :: (Int), Syn_Nonterminals -> Nonterminals
self_Syn_Nonterminals :: (Nonterminals), Syn_Nonterminals -> SF_P
sfp_Syn_Nonterminals :: (SF_P), Syn_Nonterminals -> Map NontermIdent (Map NontermIdent Type)
synmap_Syn_Nonterminals :: (Map.Map NontermIdent Attributes), Syn_Nonterminals -> AI_N
syns_Syn_Nonterminals :: (AS_N), Syn_Nonterminals -> IntMap Int
visMap_Syn_Nonterminals :: (IMap.IntMap Int), Syn_Nonterminals -> Int
visitnum_Syn_Nonterminals :: (Int) }
{-# INLINABLE wrap_Nonterminals #-}
wrap_Nonterminals :: T_Nonterminals  -> Inh_Nonterminals  -> (Syn_Nonterminals )
wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> Syn_Nonterminals
wrap_Nonterminals (T_Nonterminals Identity T_Nonterminals_s74
act) (Inh_Nonterminals MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Nonterminals_s74
sem <- Identity T_Nonterminals_s74
act
        let arg73 :: T_Nonterminals_vIn73
arg73 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> (MyType -> MyAttributes)
-> AttrOrderMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> InterfaceRes
-> TDPRes
-> IntMap Int
-> Int
-> T_Nonterminals_vIn73
T_Nonterminals_vIn73 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum
        (T_Nonterminals_vOut73 [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminals
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Nonterminals_s74 -> T_Nonterminals_v73
inv_Nonterminals_s74 T_Nonterminals_s74
sem T_Nonterminals_vIn73
arg73)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([Edge]
-> A_P
-> ENonterminals
-> AttrOrderMap
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Map MyOccurrence NontermIdent
-> Int
-> Nonterminals
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> IntMap Int
-> Int
-> Syn_Nonterminals
Syn_Nonterminals [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminals
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum)
   )

-- cata
{-# NOINLINE sem_Nonterminals #-}
sem_Nonterminals :: Nonterminals  -> T_Nonterminals 
sem_Nonterminals :: Nonterminals -> T_Nonterminals
sem_Nonterminals Nonterminals
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons T_Nonterminals
sem_Nonterminals_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Nonterminal -> T_Nonterminal
sem_Nonterminal Nonterminals
list)

-- semantic domain
newtype T_Nonterminals  = T_Nonterminals {
                                         T_Nonterminals -> Identity T_Nonterminals_s74
attach_T_Nonterminals :: Identity (T_Nonterminals_s74 )
                                         }
newtype T_Nonterminals_s74  = C_Nonterminals_s74 {
                                                 T_Nonterminals_s74 -> T_Nonterminals_v73
inv_Nonterminals_s74 :: (T_Nonterminals_v73 )
                                                 }
data T_Nonterminals_s75  = C_Nonterminals_s75
type T_Nonterminals_v73  = (T_Nonterminals_vIn73 ) -> (T_Nonterminals_vOut73 )
data T_Nonterminals_vIn73  = T_Nonterminals_vIn73 (MyType -> MyAttributes) (MyType -> MyAttributes) (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) (MyType -> MyAttributes) (Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))) (ContextMap) (Map NontermIdent (Set NontermIdent)) (Map NontermIdent (Set NontermIdent)) (Map NontermIdent (Set NontermIdent)) (Int) (FTY) (FTY) (HOMap) (SF_P) (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) (NMP) (NMP_R) (Int) (Options) (PMP) (PMP_R) ([Edge]) (Int) (InterfaceRes) (TDPRes) (IMap.IntMap Int) (Int)
data T_Nonterminals_vOut73  = T_Nonterminals_vOut73 ([Edge]) (A_P) (ENonterminals) (AttrOrderMap) (FMap) (Int) (FsInP) (FTY) (Map Int Int) (HOMap) (Map.Map NontermIdent Attributes) (AI_N) (Map Int [Int]) (SF_P) (SF_P) (Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))) (Map NontermIdent (Set NontermIdent)) (Map NontermIdent (Set NontermIdent)) ([(Int, Int)]) (Int) (PMP) (PMP_R) ([PLabel]) (Map.Map MyOccurrence Identifier) (Int) (Nonterminals) (SF_P) (Map.Map NontermIdent Attributes) (AS_N) (IMap.IntMap Int) (Int)
{-# NOINLINE sem_Nonterminals_Cons #-}
sem_Nonterminals_Cons :: T_Nonterminal  -> T_Nonterminals  -> T_Nonterminals 
sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons T_Nonterminal
arg_hd_ T_Nonterminals
arg_tl_ = Identity T_Nonterminals_s74 -> T_Nonterminals
T_Nonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminals_s74
st74) where
   {-# NOINLINE st74 #-}
   st74 :: T_Nonterminals_s74
st74 = let
      v73 :: T_Nonterminals_v73 
      v73 :: T_Nonterminals_v73
v73 = \ (T_Nonterminals_vIn73 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _hdX71 :: T_Nonterminal_s71
_hdX71 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminal -> Identity T_Nonterminal_s71
attach_T_Nonterminal (T_Nonterminal
arg_hd_))
         _tlX74 :: T_Nonterminals_s74
_tlX74 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s74
attach_T_Nonterminals (T_Nonterminals
arg_tl_))
         (T_Nonterminal_vOut70 [Edge]
_hdIads A_P
_hdIap ENonterminals
_hdIenonts AttrOrderMap
_hdIfdps FMap
_hdIfieldMap Int
_hdIflab Map PLabel [(PLabel, FLabel)]
_hdIfsInP FTY
_hdIfty Map Int Int
_hdIgen HOMap
_hdIhoMap Map NontermIdent (Map NontermIdent Type)
_hdIinhmap AI_N
_hdIinhs Map Int [Int]
_hdIinss SF_P
_hdIlfp SF_P
_hdIlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_hdIlocalSigMap Map NontermIdent (Set NontermIdent)
_hdIntDeps Map NontermIdent (Set NontermIdent)
_hdIntHoDeps [Edge]
_hdIofld Int
_hdIolab PMP
_hdIpmp PMP_R
_hdIpmpr [PLabel]
_hdIps Map MyOccurrence NontermIdent
_hdIruleMap Int
_hdIrulenumber Nonterminal
_hdIself SF_P
_hdIsfp Map NontermIdent (Map NontermIdent Type)
_hdIsynmap AI_N
_hdIsyns IntMap Int
_hdIvisMap Int
_hdIvisitnum) = T_Nonterminal_s71 -> T_Nonterminal_v70
inv_Nonterminal_s71 T_Nonterminal_s71
_hdX71 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> (MyType -> MyAttributes)
-> AttrOrderMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> InterfaceRes
-> TDPRes
-> IntMap Int
-> Int
-> T_Nonterminal_vIn70
T_Nonterminal_vIn70 MyType -> MyAttributes
_hdOain MyType -> MyAttributes
_hdOan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdOaroundMap MyType -> MyAttributes
_hdOasn AttrOrderMap
_hdOaugM ContextMap
_hdOclassContexts Map NontermIdent (Set NontermIdent)
_hdOclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_hdOclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_hdOclosedNtDeps Int
_hdOflab FTY
_hdOfty FTY
_hdOftyf HOMap
_hdOhoMapf SF_P
_hdOlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_hdOmergeMap NMP
_hdOnmp NMP_R
_hdOnmprf Int
_hdOolab Options
_hdOoptions PMP
_hdOpmpf PMP_R
_hdOpmprf [Edge]
_hdOres_ads Int
_hdOrulenumber InterfaceRes
_hdOsched TDPRes
_hdOtdp IntMap Int
_hdOvisMapf Int
_hdOvisitnum)
         (T_Nonterminals_vOut73 [Edge]
_tlIads A_P
_tlIap ENonterminals
_tlIenonts AttrOrderMap
_tlIfdps FMap
_tlIfieldMap Int
_tlIflab Map PLabel [(PLabel, FLabel)]
_tlIfsInP FTY
_tlIfty Map Int Int
_tlIgen HOMap
_tlIhoMap Map NontermIdent (Map NontermIdent Type)
_tlIinhmap AI_N
_tlIinhs Map Int [Int]
_tlIinss SF_P
_tlIlfp SF_P
_tlIlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_tlIlocalSigMap Map NontermIdent (Set NontermIdent)
_tlIntDeps Map NontermIdent (Set NontermIdent)
_tlIntHoDeps [Edge]
_tlIofld Int
_tlIolab PMP
_tlIpmp PMP_R
_tlIpmpr [PLabel]
_tlIps Map MyOccurrence NontermIdent
_tlIruleMap Int
_tlIrulenumber Nonterminals
_tlIself SF_P
_tlIsfp Map NontermIdent (Map NontermIdent Type)
_tlIsynmap AI_N
_tlIsyns IntMap Int
_tlIvisMap Int
_tlIvisitnum) = T_Nonterminals_s74 -> T_Nonterminals_v73
inv_Nonterminals_s74 T_Nonterminals_s74
_tlX74 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> (MyType -> MyAttributes)
-> AttrOrderMap
-> ContextMap
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> InterfaceRes
-> TDPRes
-> IntMap Int
-> Int
-> T_Nonterminals_vIn73
T_Nonterminals_vIn73 MyType -> MyAttributes
_tlOain MyType -> MyAttributes
_tlOan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlOaroundMap MyType -> MyAttributes
_tlOasn AttrOrderMap
_tlOaugM ContextMap
_tlOclassContexts Map NontermIdent (Set NontermIdent)
_tlOclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_tlOclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_tlOclosedNtDeps Int
_tlOflab FTY
_tlOfty FTY
_tlOftyf HOMap
_tlOhoMapf SF_P
_tlOlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_tlOmergeMap NMP
_tlOnmp NMP_R
_tlOnmprf Int
_tlOolab Options
_tlOoptions PMP
_tlOpmpf PMP_R
_tlOpmprf [Edge]
_tlOres_ads Int
_tlOrulenumber InterfaceRes
_tlOsched TDPRes
_tlOtdp IntMap Int
_tlOvisMapf Int
_tlOvisitnum)
         _lhsOads :: [Edge]
         _lhsOads :: [Edge]
_lhsOads = [Edge] -> [Edge] -> [Edge]
rule423 [Edge]
_hdIads [Edge]
_tlIads
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P -> A_P
rule424 A_P
_hdIap A_P
_tlIap
         _lhsOenonts :: ENonterminals
         _lhsOenonts :: ENonterminals
_lhsOenonts = ENonterminals -> ENonterminals -> ENonterminals
rule425 ENonterminals
_hdIenonts ENonterminals
_tlIenonts
         _lhsOfdps :: AttrOrderMap
         _lhsOfdps :: AttrOrderMap
_lhsOfdps = AttrOrderMap -> AttrOrderMap -> AttrOrderMap
rule426 AttrOrderMap
_hdIfdps AttrOrderMap
_tlIfdps
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = FMap -> FMap -> FMap
rule427 FMap
_hdIfieldMap FMap
_tlIfieldMap
         _lhsOfsInP :: FsInP
         _lhsOfsInP :: Map PLabel [(PLabel, FLabel)]
_lhsOfsInP = Map PLabel [(PLabel, FLabel)]
-> Map PLabel [(PLabel, FLabel)] -> Map PLabel [(PLabel, FLabel)]
rule428 Map PLabel [(PLabel, FLabel)]
_hdIfsInP Map PLabel [(PLabel, FLabel)]
_tlIfsInP
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = FTY -> FTY -> FTY
rule429 FTY
_hdIfty FTY
_tlIfty
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int -> Map Int Int
rule430 Map Int Int
_hdIgen Map Int Int
_tlIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = HOMap -> HOMap -> HOMap
rule431 HOMap
_hdIhoMap HOMap
_tlIhoMap
         _lhsOinhmap :: Map.Map NontermIdent Attributes
         _lhsOinhmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap = Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule432 Map NontermIdent (Map NontermIdent Type)
_hdIinhmap Map NontermIdent (Map NontermIdent Type)
_tlIinhmap
         _lhsOinhs :: AI_N
         _lhsOinhs :: AI_N
_lhsOinhs = AI_N -> AI_N -> AI_N
rule433 AI_N
_hdIinhs AI_N
_tlIinhs
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule434 Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = SF_P -> SF_P -> SF_P
rule435 SF_P
_hdIlfp SF_P
_tlIlfp
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = SF_P -> SF_P -> SF_P
rule436 SF_P
_hdIlfpr SF_P
_tlIlfpr
         _lhsOlocalSigMap :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap = Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
rule437 Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_hdIlocalSigMap Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_tlIlocalSigMap
         _lhsOntDeps :: Map NontermIdent (Set NontermIdent)
         _lhsOntDeps :: Map NontermIdent (Set NontermIdent)
_lhsOntDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule438 Map NontermIdent (Set NontermIdent)
_hdIntDeps Map NontermIdent (Set NontermIdent)
_tlIntDeps
         _lhsOntHoDeps :: Map NontermIdent (Set NontermIdent)
         _lhsOntHoDeps :: Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule439 Map NontermIdent (Set NontermIdent)
_hdIntHoDeps Map NontermIdent (Set NontermIdent)
_tlIntHoDeps
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge] -> [Edge]
rule440 [Edge]
_hdIofld [Edge]
_tlIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP -> PMP
rule441 PMP
_hdIpmp PMP
_tlIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R -> PMP_R
rule442 PMP_R
_hdIpmpr PMP_R
_tlIpmpr
         _lhsOps :: [PLabel]
         _lhsOps :: [PLabel]
_lhsOps = [PLabel] -> [PLabel] -> [PLabel]
rule443 [PLabel]
_hdIps [PLabel]
_tlIps
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = Map MyOccurrence NontermIdent
-> Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule444 Map MyOccurrence NontermIdent
_hdIruleMap Map MyOccurrence NontermIdent
_tlIruleMap
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = SF_P -> SF_P -> SF_P
rule445 SF_P
_hdIsfp SF_P
_tlIsfp
         _lhsOsynmap :: Map.Map NontermIdent Attributes
         _lhsOsynmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap = Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule446 Map NontermIdent (Map NontermIdent Type)
_hdIsynmap Map NontermIdent (Map NontermIdent Type)
_tlIsynmap
         _lhsOsyns :: AS_N
         _lhsOsyns :: AI_N
_lhsOsyns = AI_N -> AI_N -> AI_N
rule447 AI_N
_hdIsyns AI_N
_tlIsyns
         _lhsOvisMap :: IMap.IntMap Int
         _lhsOvisMap :: IntMap Int
_lhsOvisMap = IntMap Int -> IntMap Int -> IntMap Int
rule448 IntMap Int
_hdIvisMap IntMap Int
_tlIvisMap
         _self :: Nonterminals
_self = Nonterminal -> Nonterminals -> Nonterminals
rule449 Nonterminal
_hdIself Nonterminals
_tlIself
         _lhsOself :: Nonterminals
         _lhsOself :: Nonterminals
_lhsOself = forall a. a -> a
rule450 Nonterminals
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule451 Int
_tlIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule452 Int
_tlIolab
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule453 Int
_tlIrulenumber
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule454 Int
_tlIvisitnum
         _hdOain :: MyType -> MyAttributes
_hdOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule455 MyType -> MyAttributes
_lhsIain
         _hdOan :: MyType -> MyAttributes
_hdOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule456 MyType -> MyAttributes
_lhsIan
         _hdOaroundMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdOaroundMap = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule457 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap
         _hdOasn :: MyType -> MyAttributes
_hdOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule458 MyType -> MyAttributes
_lhsIasn
         _hdOaugM :: AttrOrderMap
_hdOaugM = AttrOrderMap -> AttrOrderMap
rule459 AttrOrderMap
_lhsIaugM
         _hdOclassContexts :: ContextMap
_hdOclassContexts = ContextMap -> ContextMap
rule460 ContextMap
_lhsIclassContexts
         _hdOclosedHoNtDeps :: Map NontermIdent (Set NontermIdent)
_hdOclosedHoNtDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule461 Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps
         _hdOclosedHoNtRevDeps :: Map NontermIdent (Set NontermIdent)
_hdOclosedHoNtRevDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule462 Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps
         _hdOclosedNtDeps :: Map NontermIdent (Set NontermIdent)
_hdOclosedNtDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule463 Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps
         _hdOflab :: Int
_hdOflab = Int -> Int
rule464 Int
_lhsIflab
         _hdOfty :: FTY
_hdOfty = FTY -> FTY
rule465 FTY
_lhsIfty
         _hdOftyf :: FTY
_hdOftyf = FTY -> FTY
rule466 FTY
_lhsIftyf
         _hdOhoMapf :: HOMap
_hdOhoMapf = HOMap -> HOMap
rule467 HOMap
_lhsIhoMapf
         _hdOlfpf :: SF_P
_hdOlfpf = SF_P -> SF_P
rule468 SF_P
_lhsIlfpf
         _hdOmergeMap :: Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_hdOmergeMap = Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
rule469 Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap
         _hdOnmp :: NMP
_hdOnmp = NMP -> NMP
rule470 NMP
_lhsInmp
         _hdOnmprf :: NMP_R
_hdOnmprf = NMP_R -> NMP_R
rule471 NMP_R
_lhsInmprf
         _hdOolab :: Int
_hdOolab = Int -> Int
rule472 Int
_lhsIolab
         _hdOoptions :: Options
_hdOoptions = Options -> Options
rule473 Options
_lhsIoptions
         _hdOpmpf :: PMP
_hdOpmpf = PMP -> PMP
rule474 PMP
_lhsIpmpf
         _hdOpmprf :: PMP_R
_hdOpmprf = PMP_R -> PMP_R
rule475 PMP_R
_lhsIpmprf
         _hdOres_ads :: [Edge]
_hdOres_ads = [Edge] -> [Edge]
rule476 [Edge]
_lhsIres_ads
         _hdOrulenumber :: Int
_hdOrulenumber = Int -> Int
rule477 Int
_lhsIrulenumber
         _hdOsched :: InterfaceRes
_hdOsched = InterfaceRes -> InterfaceRes
rule478 InterfaceRes
_lhsIsched
         _hdOtdp :: TDPRes
_hdOtdp = TDPRes -> TDPRes
rule479 TDPRes
_lhsItdp
         _hdOvisMapf :: IntMap Int
_hdOvisMapf = IntMap Int -> IntMap Int
rule480 IntMap Int
_lhsIvisMapf
         _hdOvisitnum :: Int
_hdOvisitnum = Int -> Int
rule481 Int
_lhsIvisitnum
         _tlOain :: MyType -> MyAttributes
_tlOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule482 MyType -> MyAttributes
_lhsIain
         _tlOan :: MyType -> MyAttributes
_tlOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule483 MyType -> MyAttributes
_lhsIan
         _tlOaroundMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlOaroundMap = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule484 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap
         _tlOasn :: MyType -> MyAttributes
_tlOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule485 MyType -> MyAttributes
_lhsIasn
         _tlOaugM :: AttrOrderMap
_tlOaugM = AttrOrderMap -> AttrOrderMap
rule486 AttrOrderMap
_lhsIaugM
         _tlOclassContexts :: ContextMap
_tlOclassContexts = ContextMap -> ContextMap
rule487 ContextMap
_lhsIclassContexts
         _tlOclosedHoNtDeps :: Map NontermIdent (Set NontermIdent)
_tlOclosedHoNtDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule488 Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps
         _tlOclosedHoNtRevDeps :: Map NontermIdent (Set NontermIdent)
_tlOclosedHoNtRevDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule489 Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps
         _tlOclosedNtDeps :: Map NontermIdent (Set NontermIdent)
_tlOclosedNtDeps = Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule490 Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps
         _tlOflab :: Int
_tlOflab = Int -> Int
rule491 Int
_hdIflab
         _tlOfty :: FTY
_tlOfty = FTY -> FTY
rule492 FTY
_hdIfty
         _tlOftyf :: FTY
_tlOftyf = FTY -> FTY
rule493 FTY
_lhsIftyf
         _tlOhoMapf :: HOMap
_tlOhoMapf = HOMap -> HOMap
rule494 HOMap
_lhsIhoMapf
         _tlOlfpf :: SF_P
_tlOlfpf = SF_P -> SF_P
rule495 SF_P
_lhsIlfpf
         _tlOmergeMap :: Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_tlOmergeMap = Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
rule496 Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap
         _tlOnmp :: NMP
_tlOnmp = NMP -> NMP
rule497 NMP
_lhsInmp
         _tlOnmprf :: NMP_R
_tlOnmprf = NMP_R -> NMP_R
rule498 NMP_R
_lhsInmprf
         _tlOolab :: Int
_tlOolab = Int -> Int
rule499 Int
_hdIolab
         _tlOoptions :: Options
_tlOoptions = Options -> Options
rule500 Options
_lhsIoptions
         _tlOpmpf :: PMP
_tlOpmpf = PMP -> PMP
rule501 PMP
_lhsIpmpf
         _tlOpmprf :: PMP_R
_tlOpmprf = PMP_R -> PMP_R
rule502 PMP_R
_lhsIpmprf
         _tlOres_ads :: [Edge]
_tlOres_ads = [Edge] -> [Edge]
rule503 [Edge]
_lhsIres_ads
         _tlOrulenumber :: Int
_tlOrulenumber = Int -> Int
rule504 Int
_hdIrulenumber
         _tlOsched :: InterfaceRes
_tlOsched = InterfaceRes -> InterfaceRes
rule505 InterfaceRes
_lhsIsched
         _tlOtdp :: TDPRes
_tlOtdp = TDPRes -> TDPRes
rule506 TDPRes
_lhsItdp
         _tlOvisMapf :: IntMap Int
_tlOvisMapf = IntMap Int -> IntMap Int
rule507 IntMap Int
_lhsIvisMapf
         _tlOvisitnum :: Int
_tlOvisitnum = Int -> Int
rule508 Int
_hdIvisitnum
         __result_ :: T_Nonterminals_vOut73
__result_ = [Edge]
-> A_P
-> ENonterminals
-> AttrOrderMap
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Map MyOccurrence NontermIdent
-> Int
-> Nonterminals
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> IntMap Int
-> Int
-> T_Nonterminals_vOut73
T_Nonterminals_vOut73 [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminals
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum
         in T_Nonterminals_vOut73
__result_ )
     in T_Nonterminals_v73 -> T_Nonterminals_s74
C_Nonterminals_s74 T_Nonterminals_v73
v73
   {-# INLINE rule423 #-}
   rule423 :: [Edge] -> [Edge] -> [Edge]
rule423 = \ (([Edge]
_hdIads) :: [Edge]) (([Edge]
_tlIads) :: [Edge]) ->
     (forall a. [a] -> [a] -> [a]
(++) [Edge]
_hdIads [Edge]
_tlIads)
   {-# INLINE rule424 #-}
   rule424 :: A_P -> A_P -> A_P
rule424 = \ ((A_P
_hdIap) :: A_P) ((A_P
_tlIap) :: A_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith forall a. [a] -> [a] -> [a]
(++) A_P
_hdIap A_P
_tlIap)
   {-# INLINE rule425 #-}
   rule425 :: ENonterminals -> ENonterminals -> ENonterminals
rule425 = \ ((ENonterminals
_hdIenonts) :: ENonterminals) ((ENonterminals
_tlIenonts) :: ENonterminals) ->
     (forall a. [a] -> [a] -> [a]
(++) ENonterminals
_hdIenonts ENonterminals
_tlIenonts)
   {-# INLINE rule426 #-}
   rule426 :: AttrOrderMap -> AttrOrderMap -> AttrOrderMap
rule426 = \ ((AttrOrderMap
_hdIfdps) :: AttrOrderMap) ((AttrOrderMap
_tlIfdps) :: AttrOrderMap) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union AttrOrderMap
_hdIfdps AttrOrderMap
_tlIfdps)
   {-# INLINE rule427 #-}
   rule427 :: FMap -> FMap -> FMap
rule427 = \ ((FMap
_hdIfieldMap) :: FMap) ((FMap
_tlIfieldMap) :: FMap) ->
     ((forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union) FMap
_hdIfieldMap FMap
_tlIfieldMap)
   {-# INLINE rule428 #-}
   rule428 :: Map PLabel [(PLabel, FLabel)]
-> Map PLabel [(PLabel, FLabel)] -> Map PLabel [(PLabel, FLabel)]
rule428 = \ ((Map PLabel [(PLabel, FLabel)]
_hdIfsInP) :: FsInP) ((Map PLabel [(PLabel, FLabel)]
_tlIfsInP) :: FsInP) ->
     ((forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union) Map PLabel [(PLabel, FLabel)]
_hdIfsInP Map PLabel [(PLabel, FLabel)]
_tlIfsInP)
   {-# INLINE rule429 #-}
   rule429 :: FTY -> FTY -> FTY
rule429 = \ ((FTY
_hdIfty) :: FTY) ((FTY
_tlIfty) :: FTY) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union FTY
_hdIfty FTY
_tlIfty)
   {-# INLINE rule430 #-}
   rule430 :: Map Int Int -> Map Int Int -> Map Int Int
rule430 = \ ((Map Int Int
_hdIgen) :: Map Int Int) ((Map Int Int
_tlIgen) :: Map Int Int) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map Int Int
_hdIgen Map Int Int
_tlIgen)
   {-# INLINE rule431 #-}
   rule431 :: HOMap -> HOMap -> HOMap
rule431 = \ ((HOMap
_hdIhoMap) :: HOMap) ((HOMap
_tlIhoMap) :: HOMap) ->
     ((forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union) HOMap
_hdIhoMap HOMap
_tlIhoMap)
   {-# INLINE rule432 #-}
   rule432 :: Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule432 = \ ((Map NontermIdent (Map NontermIdent Type)
_hdIinhmap) :: Map.Map NontermIdent Attributes) ((Map NontermIdent (Map NontermIdent Type)
_tlIinhmap) :: Map.Map NontermIdent Attributes) ->
     Map NontermIdent (Map NontermIdent Type)
_hdIinhmap forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent (Map NontermIdent Type)
_tlIinhmap
   {-# INLINE rule433 #-}
   rule433 :: AI_N -> AI_N -> AI_N
rule433 = \ ((AI_N
_hdIinhs) :: AI_N) ((AI_N
_tlIinhs) :: AI_N) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union AI_N
_hdIinhs AI_N
_tlIinhs)
   {-# INLINE rule434 #-}
   rule434 :: Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule434 = \ ((Map Int [Int]
_hdIinss) :: Map Int [Int]) ((Map Int [Int]
_tlIinss) :: Map Int [Int]) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith forall a. [a] -> [a] -> [a]
(++) Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss)
   {-# INLINE rule435 #-}
   rule435 :: SF_P -> SF_P -> SF_P
rule435 = \ ((SF_P
_hdIlfp) :: SF_P) ((SF_P
_tlIlfp) :: SF_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) SF_P
_hdIlfp SF_P
_tlIlfp)
   {-# INLINE rule436 #-}
   rule436 :: SF_P -> SF_P -> SF_P
rule436 = \ ((SF_P
_hdIlfpr) :: SF_P) ((SF_P
_tlIlfpr) :: SF_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) SF_P
_hdIlfpr SF_P
_tlIlfpr)
   {-# INLINE rule437 #-}
   rule437 :: Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
rule437 = \ ((Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_hdIlocalSigMap) :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))) ((Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_tlIlocalSigMap) :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))) ->
     Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_hdIlocalSigMap forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_tlIlocalSigMap
   {-# INLINE rule438 #-}
   rule438 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule438 = \ ((Map NontermIdent (Set NontermIdent)
_hdIntDeps) :: Map NontermIdent (Set NontermIdent)) ((Map NontermIdent (Set NontermIdent)
_tlIntDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_hdIntDeps forall a. Monoid a => a -> a -> a
`mappend` Map NontermIdent (Set NontermIdent)
_tlIntDeps
   {-# INLINE rule439 #-}
   rule439 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule439 = \ ((Map NontermIdent (Set NontermIdent)
_hdIntHoDeps) :: Map NontermIdent (Set NontermIdent)) ((Map NontermIdent (Set NontermIdent)
_tlIntHoDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_hdIntHoDeps forall a. Monoid a => a -> a -> a
`mappend` Map NontermIdent (Set NontermIdent)
_tlIntHoDeps
   {-# INLINE rule440 #-}
   rule440 :: [Edge] -> [Edge] -> [Edge]
rule440 = \ (([Edge]
_hdIofld) :: [(Int, Int)]) (([Edge]
_tlIofld) :: [(Int, Int)]) ->
     (forall a. [a] -> [a] -> [a]
(++) [Edge]
_hdIofld [Edge]
_tlIofld)
   {-# INLINE rule441 #-}
   rule441 :: PMP -> PMP -> PMP
rule441 = \ ((PMP
_hdIpmp) :: PMP) ((PMP
_tlIpmp) :: PMP) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union PMP
_hdIpmp PMP
_tlIpmp)
   {-# INLINE rule442 #-}
   rule442 :: PMP_R -> PMP_R -> PMP_R
rule442 = \ ((PMP_R
_hdIpmpr) :: PMP_R) ((PMP_R
_tlIpmpr) :: PMP_R) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union PMP_R
_hdIpmpr PMP_R
_tlIpmpr)
   {-# INLINE rule443 #-}
   rule443 :: [PLabel] -> [PLabel] -> [PLabel]
rule443 = \ (([PLabel]
_hdIps) :: [PLabel]) (([PLabel]
_tlIps) :: [PLabel]) ->
     (forall a. [a] -> [a] -> [a]
(++) [PLabel]
_hdIps [PLabel]
_tlIps)
   {-# INLINE rule444 #-}
   rule444 :: Map MyOccurrence NontermIdent
-> Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule444 = \ ((Map MyOccurrence NontermIdent
_hdIruleMap) :: Map.Map MyOccurrence Identifier) ((Map MyOccurrence NontermIdent
_tlIruleMap) :: Map.Map MyOccurrence Identifier) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map MyOccurrence NontermIdent
_hdIruleMap Map MyOccurrence NontermIdent
_tlIruleMap)
   {-# INLINE rule445 #-}
   rule445 :: SF_P -> SF_P -> SF_P
rule445 = \ ((SF_P
_hdIsfp) :: SF_P) ((SF_P
_tlIsfp) :: SF_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) SF_P
_hdIsfp SF_P
_tlIsfp)
   {-# INLINE rule446 #-}
   rule446 :: Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule446 = \ ((Map NontermIdent (Map NontermIdent Type)
_hdIsynmap) :: Map.Map NontermIdent Attributes) ((Map NontermIdent (Map NontermIdent Type)
_tlIsynmap) :: Map.Map NontermIdent Attributes) ->
     Map NontermIdent (Map NontermIdent Type)
_hdIsynmap forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent (Map NontermIdent Type)
_tlIsynmap
   {-# INLINE rule447 #-}
   rule447 :: AI_N -> AI_N -> AI_N
rule447 = \ ((AI_N
_hdIsyns) :: AS_N) ((AI_N
_tlIsyns) :: AS_N) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union AI_N
_hdIsyns AI_N
_tlIsyns)
   {-# INLINE rule448 #-}
   rule448 :: IntMap Int -> IntMap Int -> IntMap Int
rule448 = \ ((IntMap Int
_hdIvisMap) :: IMap.IntMap Int) ((IntMap Int
_tlIvisMap) :: IMap.IntMap Int) ->
     (forall a. IntMap a -> IntMap a -> IntMap a
IMap.union IntMap Int
_hdIvisMap IntMap Int
_tlIvisMap)
   {-# INLINE rule449 #-}
   rule449 :: Nonterminal -> Nonterminals -> Nonterminals
rule449 = \ ((Nonterminal
_hdIself) :: Nonterminal) ((Nonterminals
_tlIself) :: Nonterminals) ->
     (:) Nonterminal
_hdIself Nonterminals
_tlIself
   {-# INLINE rule450 #-}
   rule450 :: p -> p
rule450 = \ p
_self ->
     p
_self
   {-# INLINE rule451 #-}
   rule451 :: Int -> Int
rule451 = \ ((Int
_tlIflab) :: Int) ->
     Int
_tlIflab
   {-# INLINE rule452 #-}
   rule452 :: Int -> Int
rule452 = \ ((Int
_tlIolab) :: Int) ->
     Int
_tlIolab
   {-# INLINE rule453 #-}
   rule453 :: Int -> Int
rule453 = \ ((Int
_tlIrulenumber) :: Int) ->
     Int
_tlIrulenumber
   {-# INLINE rule454 #-}
   rule454 :: Int -> Int
rule454 = \ ((Int
_tlIvisitnum) :: Int) ->
     Int
_tlIvisitnum
   {-# INLINE rule455 #-}
   rule455 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule455 = \ ((MyType -> MyAttributes
_lhsIain) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIain
   {-# INLINE rule456 #-}
   rule456 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule456 = \ ((MyType -> MyAttributes
_lhsIan) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIan
   {-# INLINE rule457 #-}
   rule457 :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule457 = \ ((Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
     Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap
   {-# INLINE rule458 #-}
   rule458 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule458 = \ ((MyType -> MyAttributes
_lhsIasn) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIasn
   {-# INLINE rule459 #-}
   rule459 :: AttrOrderMap -> AttrOrderMap
rule459 = \ ((AttrOrderMap
_lhsIaugM) :: Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))) ->
     AttrOrderMap
_lhsIaugM
   {-# INLINE rule460 #-}
   rule460 :: ContextMap -> ContextMap
rule460 = \ ((ContextMap
_lhsIclassContexts) :: ContextMap) ->
     ContextMap
_lhsIclassContexts
   {-# INLINE rule461 #-}
   rule461 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule461 = \ ((Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps
   {-# INLINE rule462 #-}
   rule462 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule462 = \ ((Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps
   {-# INLINE rule463 #-}
   rule463 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule463 = \ ((Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps
   {-# INLINE rule464 #-}
   rule464 :: Int -> Int
rule464 = \ ((Int
_lhsIflab) :: Int) ->
     Int
_lhsIflab
   {-# INLINE rule465 #-}
   rule465 :: FTY -> FTY
rule465 = \ ((FTY
_lhsIfty) :: FTY) ->
     FTY
_lhsIfty
   {-# INLINE rule466 #-}
   rule466 :: FTY -> FTY
rule466 = \ ((FTY
_lhsIftyf) :: FTY) ->
     FTY
_lhsIftyf
   {-# INLINE rule467 #-}
   rule467 :: HOMap -> HOMap
rule467 = \ ((HOMap
_lhsIhoMapf) :: HOMap) ->
     HOMap
_lhsIhoMapf
   {-# INLINE rule468 #-}
   rule468 :: SF_P -> SF_P
rule468 = \ ((SF_P
_lhsIlfpf) :: SF_P) ->
     SF_P
_lhsIlfpf
   {-# INLINE rule469 #-}
   rule469 :: Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
rule469 = \ ((Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) ->
     Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap
   {-# INLINE rule470 #-}
   rule470 :: NMP -> NMP
rule470 = \ ((NMP
_lhsInmp) :: NMP) ->
     NMP
_lhsInmp
   {-# INLINE rule471 #-}
   rule471 :: NMP_R -> NMP_R
rule471 = \ ((NMP_R
_lhsInmprf) :: NMP_R) ->
     NMP_R
_lhsInmprf
   {-# INLINE rule472 #-}
   rule472 :: Int -> Int
rule472 = \ ((Int
_lhsIolab) :: Int) ->
     Int
_lhsIolab
   {-# INLINE rule473 #-}
   rule473 :: Options -> Options
rule473 = \ ((Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# INLINE rule474 #-}
   rule474 :: PMP -> PMP
rule474 = \ ((PMP
_lhsIpmpf) :: PMP) ->
     PMP
_lhsIpmpf
   {-# INLINE rule475 #-}
   rule475 :: PMP_R -> PMP_R
rule475 = \ ((PMP_R
_lhsIpmprf) :: PMP_R) ->
     PMP_R
_lhsIpmprf
   {-# INLINE rule476 #-}
   rule476 :: [Edge] -> [Edge]
rule476 = \ (([Edge]
_lhsIres_ads) :: [Edge]) ->
     [Edge]
_lhsIres_ads
   {-# INLINE rule477 #-}
   rule477 :: Int -> Int
rule477 = \ ((Int
_lhsIrulenumber) :: Int) ->
     Int
_lhsIrulenumber
   {-# INLINE rule478 #-}
   rule478 :: InterfaceRes -> InterfaceRes
rule478 = \ ((InterfaceRes
_lhsIsched) :: InterfaceRes) ->
     InterfaceRes
_lhsIsched
   {-# INLINE rule479 #-}
   rule479 :: TDPRes -> TDPRes
rule479 = \ ((TDPRes
_lhsItdp) :: TDPRes) ->
     TDPRes
_lhsItdp
   {-# INLINE rule480 #-}
   rule480 :: IntMap Int -> IntMap Int
rule480 = \ ((IntMap Int
_lhsIvisMapf) :: IMap.IntMap Int) ->
     IntMap Int
_lhsIvisMapf
   {-# INLINE rule481 #-}
   rule481 :: Int -> Int
rule481 = \ ((Int
_lhsIvisitnum) :: Int) ->
     Int
_lhsIvisitnum
   {-# INLINE rule482 #-}
   rule482 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule482 = \ ((MyType -> MyAttributes
_lhsIain) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIain
   {-# INLINE rule483 #-}
   rule483 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule483 = \ ((MyType -> MyAttributes
_lhsIan) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIan
   {-# INLINE rule484 #-}
   rule484 :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule484 = \ ((Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
     Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap
   {-# INLINE rule485 #-}
   rule485 :: (MyType -> MyAttributes) -> MyType -> MyAttributes
rule485 = \ ((MyType -> MyAttributes
_lhsIasn) :: MyType -> MyAttributes) ->
     MyType -> MyAttributes
_lhsIasn
   {-# INLINE rule486 #-}
   rule486 :: AttrOrderMap -> AttrOrderMap
rule486 = \ ((AttrOrderMap
_lhsIaugM) :: Map.Map Identifier (Map.Map Identifier (Set.Set Dependency))) ->
     AttrOrderMap
_lhsIaugM
   {-# INLINE rule487 #-}
   rule487 :: ContextMap -> ContextMap
rule487 = \ ((ContextMap
_lhsIclassContexts) :: ContextMap) ->
     ContextMap
_lhsIclassContexts
   {-# INLINE rule488 #-}
   rule488 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule488 = \ ((Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps
   {-# INLINE rule489 #-}
   rule489 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule489 = \ ((Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps
   {-# INLINE rule490 #-}
   rule490 :: Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
rule490 = \ ((Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps) :: Map NontermIdent (Set NontermIdent)) ->
     Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps
   {-# INLINE rule491 #-}
   rule491 :: Int -> Int
rule491 = \ ((Int
_hdIflab) :: Int) ->
     Int
_hdIflab
   {-# INLINE rule492 #-}
   rule492 :: FTY -> FTY
rule492 = \ ((FTY
_hdIfty) :: FTY) ->
     FTY
_hdIfty
   {-# INLINE rule493 #-}
   rule493 :: FTY -> FTY
rule493 = \ ((FTY
_lhsIftyf) :: FTY) ->
     FTY
_lhsIftyf
   {-# INLINE rule494 #-}
   rule494 :: HOMap -> HOMap
rule494 = \ ((HOMap
_lhsIhoMapf) :: HOMap) ->
     HOMap
_lhsIhoMapf
   {-# INLINE rule495 #-}
   rule495 :: SF_P -> SF_P
rule495 = \ ((SF_P
_lhsIlfpf) :: SF_P) ->
     SF_P
_lhsIlfpf
   {-# INLINE rule496 #-}
   rule496 :: Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
rule496 = \ ((Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap) :: Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) ->
     Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap
   {-# INLINE rule497 #-}
   rule497 :: NMP -> NMP
rule497 = \ ((NMP
_lhsInmp) :: NMP) ->
     NMP
_lhsInmp
   {-# INLINE rule498 #-}
   rule498 :: NMP_R -> NMP_R
rule498 = \ ((NMP_R
_lhsInmprf) :: NMP_R) ->
     NMP_R
_lhsInmprf
   {-# INLINE rule499 #-}
   rule499 :: Int -> Int
rule499 = \ ((Int
_hdIolab) :: Int) ->
     Int
_hdIolab
   {-# INLINE rule500 #-}
   rule500 :: Options -> Options
rule500 = \ ((Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# INLINE rule501 #-}
   rule501 :: PMP -> PMP
rule501 = \ ((PMP
_lhsIpmpf) :: PMP) ->
     PMP
_lhsIpmpf
   {-# INLINE rule502 #-}
   rule502 :: PMP_R -> PMP_R
rule502 = \ ((PMP_R
_lhsIpmprf) :: PMP_R) ->
     PMP_R
_lhsIpmprf
   {-# INLINE rule503 #-}
   rule503 :: [Edge] -> [Edge]
rule503 = \ (([Edge]
_lhsIres_ads) :: [Edge]) ->
     [Edge]
_lhsIres_ads
   {-# INLINE rule504 #-}
   rule504 :: Int -> Int
rule504 = \ ((Int
_hdIrulenumber) :: Int) ->
     Int
_hdIrulenumber
   {-# INLINE rule505 #-}
   rule505 :: InterfaceRes -> InterfaceRes
rule505 = \ ((InterfaceRes
_lhsIsched) :: InterfaceRes) ->
     InterfaceRes
_lhsIsched
   {-# INLINE rule506 #-}
   rule506 :: TDPRes -> TDPRes
rule506 = \ ((TDPRes
_lhsItdp) :: TDPRes) ->
     TDPRes
_lhsItdp
   {-# INLINE rule507 #-}
   rule507 :: IntMap Int -> IntMap Int
rule507 = \ ((IntMap Int
_lhsIvisMapf) :: IMap.IntMap Int) ->
     IntMap Int
_lhsIvisMapf
   {-# INLINE rule508 #-}
   rule508 :: Int -> Int
rule508 = \ ((Int
_hdIvisitnum) :: Int) ->
     Int
_hdIvisitnum
{-# NOINLINE sem_Nonterminals_Nil #-}
sem_Nonterminals_Nil ::  T_Nonterminals 
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil  = Identity T_Nonterminals_s74 -> T_Nonterminals
T_Nonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminals_s74
st74) where
   {-# NOINLINE st74 #-}
   st74 :: T_Nonterminals_s74
st74 = let
      v73 :: T_Nonterminals_v73 
      v73 :: T_Nonterminals_v73
v73 = \ (T_Nonterminals_vIn73 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn AttrOrderMap
_lhsIaugM ContextMap
_lhsIclassContexts Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedHoNtRevDeps Map NontermIdent (Set NontermIdent)
_lhsIclosedNtDeps Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
_lhsImergeMap NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber InterfaceRes
_lhsIsched TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _lhsOads :: [Edge]
         _lhsOads :: [Edge]
_lhsOads = forall {a}. () -> [a]
rule509  ()
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = forall {k} {a}. () -> Map k a
rule510  ()
         _lhsOenonts :: ENonterminals
         _lhsOenonts :: ENonterminals
_lhsOenonts = forall {a}. () -> [a]
rule511  ()
         _lhsOfdps :: AttrOrderMap
         _lhsOfdps :: AttrOrderMap
_lhsOfdps = forall {k} {a}. () -> Map k a
rule512  ()
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = forall {k} {a}. () -> Map k a
rule513  ()
         _lhsOfsInP :: FsInP
         _lhsOfsInP :: Map PLabel [(PLabel, FLabel)]
_lhsOfsInP = forall {k} {a}. () -> Map k a
rule514  ()
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = forall {k} {a}. () -> Map k a
rule515  ()
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = forall {k} {a}. () -> Map k a
rule516  ()
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = forall {k} {a}. () -> Map k a
rule517  ()
         _lhsOinhmap :: Map.Map NontermIdent Attributes
         _lhsOinhmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap = forall {k} {a}. () -> Map k a
rule518  ()
         _lhsOinhs :: AI_N
         _lhsOinhs :: AI_N
_lhsOinhs = forall {k} {a}. () -> Map k a
rule519  ()
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = forall {k} {a}. () -> Map k a
rule520  ()
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = forall {k} {a}. () -> Map k a
rule521  ()
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = forall {k} {a}. () -> Map k a
rule522  ()
         _lhsOlocalSigMap :: Map.Map NontermIdent (Map.Map ConstructorIdent (Map.Map Identifier Type))
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap = forall {k} {a}. () -> Map k a
rule523  ()
         _lhsOntDeps :: Map NontermIdent (Set NontermIdent)
         _lhsOntDeps :: Map NontermIdent (Set NontermIdent)
_lhsOntDeps = () -> Map NontermIdent (Set NontermIdent)
rule524  ()
         _lhsOntHoDeps :: Map NontermIdent (Set NontermIdent)
         _lhsOntHoDeps :: Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps = () -> Map NontermIdent (Set NontermIdent)
rule525  ()
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = forall {a}. () -> [a]
rule526  ()
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = forall {k} {a}. () -> Map k a
rule527  ()
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = forall {k} {a}. () -> Map k a
rule528  ()
         _lhsOps :: [PLabel]
         _lhsOps :: [PLabel]
_lhsOps = forall {a}. () -> [a]
rule529  ()
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = forall {k} {a}. () -> Map k a
rule530  ()
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = forall {k} {a}. () -> Map k a
rule531  ()
         _lhsOsynmap :: Map.Map NontermIdent Attributes
         _lhsOsynmap :: Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap = forall {k} {a}. () -> Map k a
rule532  ()
         _lhsOsyns :: AS_N
         _lhsOsyns :: AI_N
_lhsOsyns = forall {k} {a}. () -> Map k a
rule533  ()
         _lhsOvisMap :: IMap.IntMap Int
         _lhsOvisMap :: IntMap Int
_lhsOvisMap = forall {a}. () -> IntMap a
rule534  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule535  ()
         _lhsOself :: Nonterminals
         _lhsOself :: Nonterminals
_lhsOself = forall a. a -> a
rule536 forall a. [a]
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule537 Int
_lhsIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule538 Int
_lhsIolab
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule539 Int
_lhsIrulenumber
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule540 Int
_lhsIvisitnum
         __result_ :: T_Nonterminals_vOut73
__result_ = [Edge]
-> A_P
-> ENonterminals
-> AttrOrderMap
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
-> Map NontermIdent (Set NontermIdent)
-> Map NontermIdent (Set NontermIdent)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Map MyOccurrence NontermIdent
-> Int
-> Nonterminals
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> AI_N
-> IntMap Int
-> Int
-> T_Nonterminals_vOut73
T_Nonterminals_vOut73 [Edge]
_lhsOads A_P
_lhsOap ENonterminals
_lhsOenonts AttrOrderMap
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map NontermIdent (Map NontermIdent Type)
_lhsOinhmap AI_N
_lhsOinhs Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent (Map NontermIdent Type))
_lhsOlocalSigMap Map NontermIdent (Set NontermIdent)
_lhsOntDeps Map NontermIdent (Set NontermIdent)
_lhsOntHoDeps [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Nonterminals
_lhsOself SF_P
_lhsOsfp Map NontermIdent (Map NontermIdent Type)
_lhsOsynmap AI_N
_lhsOsyns IntMap Int
_lhsOvisMap Int
_lhsOvisitnum
         in T_Nonterminals_vOut73
__result_ )
     in T_Nonterminals_v73 -> T_Nonterminals_s74
C_Nonterminals_s74 T_Nonterminals_v73
v73
   {-# INLINE rule509 #-}
   rule509 :: () -> [a]
rule509 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule510 #-}
   rule510 :: () -> Map k a
rule510 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule511 #-}
   rule511 :: () -> [a]
rule511 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule512 #-}
   rule512 :: () -> Map k a
rule512 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule513 #-}
   rule513 :: () -> Map k a
rule513 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule514 #-}
   rule514 :: () -> Map k a
rule514 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule515 #-}
   rule515 :: () -> Map k a
rule515 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule516 #-}
   rule516 :: () -> Map k a
rule516 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule517 #-}
   rule517 :: () -> Map k a
rule517 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule518 #-}
   rule518 :: () -> Map k a
rule518 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule519 #-}
   rule519 :: () -> Map k a
rule519 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule520 #-}
   rule520 :: () -> Map k a
rule520 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule521 #-}
   rule521 :: () -> Map k a
rule521 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule522 #-}
   rule522 :: () -> Map k a
rule522 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule523 #-}
   rule523 :: () -> Map k a
rule523 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule524 #-}
   rule524 :: () -> Map NontermIdent (Set NontermIdent)
rule524 = \  (()
_ :: ()) ->
     forall a. Monoid a => a
mempty
   {-# INLINE rule525 #-}
   rule525 :: () -> Map NontermIdent (Set NontermIdent)
rule525 = \  (()
_ :: ()) ->
     forall a. Monoid a => a
mempty
   {-# INLINE rule526 #-}
   rule526 :: () -> [a]
rule526 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule527 #-}
   rule527 :: () -> Map k a
rule527 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule528 #-}
   rule528 :: () -> Map k a
rule528 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule529 #-}
   rule529 :: () -> [a]
rule529 = \  (()
_ :: ()) ->
     ([])
   {-# INLINE rule530 #-}
   rule530 :: () -> Map k a
rule530 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule531 #-}
   rule531 :: () -> Map k a
rule531 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule532 #-}
   rule532 :: () -> Map k a
rule532 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule533 #-}
   rule533 :: () -> Map k a
rule533 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule534 #-}
   rule534 :: () -> IntMap a
rule534 = \  (()
_ :: ()) ->
     forall a. IntMap a
IMap.empty
   {-# INLINE rule535 #-}
   rule535 :: () -> [a]
rule535 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule536 #-}
   rule536 :: p -> p
rule536 = \ p
_self ->
     p
_self
   {-# INLINE rule537 #-}
   rule537 :: Int -> Int
rule537 = \ ((Int
_lhsIflab) :: Int) ->
     Int
_lhsIflab
   {-# INLINE rule538 #-}
   rule538 :: Int -> Int
rule538 = \ ((Int
_lhsIolab) :: Int) ->
     Int
_lhsIolab
   {-# INLINE rule539 #-}
   rule539 :: Int -> Int
rule539 = \ ((Int
_lhsIrulenumber) :: Int) ->
     Int
_lhsIrulenumber
   {-# INLINE rule540 #-}
   rule540 :: Int -> Int
rule540 = \ ((Int
_lhsIvisitnum) :: Int) ->
     Int
_lhsIvisitnum

-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern  = Inh_Pattern {  }
data Syn_Pattern  = Syn_Pattern { Syn_Pattern -> [(FLabel, (FLabel, Direction), Bool)]
afs_Syn_Pattern :: ([(FLabel, ALabel, Bool)]), Syn_Pattern -> Pattern
copy_Syn_Pattern :: (Pattern), Syn_Pattern -> Pattern
self_Syn_Pattern :: (Pattern) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern  -> Inh_Pattern  -> (Syn_Pattern )
wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern
wrap_Pattern (T_Pattern Identity T_Pattern_s77
act) (Inh_Pattern
Inh_Pattern ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Pattern_s77
sem <- Identity T_Pattern_s77
act
        let arg76 :: T_Pattern_vIn76
arg76 = T_Pattern_vIn76
T_Pattern_vIn76 
        (T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 T_Pattern_s77
sem T_Pattern_vIn76
arg76)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([(FLabel, (FLabel, Direction), Bool)]
-> Pattern -> Pattern -> Syn_Pattern
Syn_Pattern [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself)
   )

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

-- semantic domain
newtype T_Pattern  = T_Pattern {
                               T_Pattern -> Identity T_Pattern_s77
attach_T_Pattern :: Identity (T_Pattern_s77 )
                               }
newtype T_Pattern_s77  = C_Pattern_s77 {
                                       T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 :: (T_Pattern_v76 )
                                       }
data T_Pattern_s78  = C_Pattern_s78
type T_Pattern_v76  = (T_Pattern_vIn76 ) -> (T_Pattern_vOut76 )
data T_Pattern_vIn76  = T_Pattern_vIn76 
data T_Pattern_vOut76  = T_Pattern_vOut76 ([(FLabel, ALabel, Bool)]) (Pattern) (Pattern)
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns  -> T_Pattern 
sem_Pattern_Constr :: NontermIdent -> T_Patterns -> T_Pattern
sem_Pattern_Constr NontermIdent
arg_name_ T_Patterns
arg_pats_ = Identity T_Pattern_s77 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s77
st77) where
   {-# NOINLINE st77 #-}
   st77 :: T_Pattern_s77
st77 = let
      v76 :: T_Pattern_v76 
      v76 :: T_Pattern_v76
v76 = \ (T_Pattern_vIn76
T_Pattern_vIn76 ) -> ( let
         _patsX80 :: T_Patterns_s80
_patsX80 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s80
attach_T_Patterns (T_Patterns
arg_pats_))
         (T_Patterns_vOut79 [(FLabel, (FLabel, Direction), Bool)]
_patsIafs Patterns
_patsIcopy Patterns
_patsIself) = T_Patterns_s80 -> T_Patterns_v79
inv_Patterns_s80 T_Patterns_s80
_patsX80 (T_Patterns_vIn79
T_Patterns_vIn79 )
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule541 [(FLabel, (FLabel, Direction), Bool)]
_patsIafs
         _copy :: Pattern
_copy = Patterns -> NontermIdent -> Pattern
rule542 Patterns
_patsIcopy NontermIdent
arg_name_
         _self :: Pattern
_self = Patterns -> NontermIdent -> Pattern
rule543 Patterns
_patsIself NontermIdent
arg_name_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule544 Pattern
_copy
         _lhsOself :: Pattern
         _lhsOself :: Pattern
_lhsOself = forall a. a -> a
rule545 Pattern
_self
         __result_ :: T_Pattern_vOut76
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Pattern -> Pattern -> T_Pattern_vOut76
T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself
         in T_Pattern_vOut76
__result_ )
     in T_Pattern_v76 -> T_Pattern_s77
C_Pattern_s77 T_Pattern_v76
v76
   {-# INLINE rule541 #-}
   rule541 :: [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule541 = \ (([(FLabel, (FLabel, Direction), Bool)]
_patsIafs) :: [(FLabel, ALabel, Bool)]) ->
     [(FLabel, (FLabel, Direction), Bool)]
_patsIafs
   {-# INLINE rule542 #-}
   rule542 :: Patterns -> NontermIdent -> Pattern
rule542 = \ ((Patterns
_patsIcopy) :: Patterns) NontermIdent
name_ ->
     NontermIdent -> Patterns -> Pattern
Constr NontermIdent
name_ Patterns
_patsIcopy
   {-# INLINE rule543 #-}
   rule543 :: Patterns -> NontermIdent -> Pattern
rule543 = \ ((Patterns
_patsIself) :: Patterns) NontermIdent
name_ ->
     NontermIdent -> Patterns -> Pattern
Constr NontermIdent
name_ Patterns
_patsIself
   {-# INLINE rule544 #-}
   rule544 :: p -> p
rule544 = \ p
_copy ->
     p
_copy
   {-# INLINE rule545 #-}
   rule545 :: p -> p
rule545 = \ p
_self ->
     p
_self
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns  -> T_Pattern 
sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern
sem_Pattern_Product Pos
arg_pos_ T_Patterns
arg_pats_ = Identity T_Pattern_s77 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s77
st77) where
   {-# NOINLINE st77 #-}
   st77 :: T_Pattern_s77
st77 = let
      v76 :: T_Pattern_v76 
      v76 :: T_Pattern_v76
v76 = \ (T_Pattern_vIn76
T_Pattern_vIn76 ) -> ( let
         _patsX80 :: T_Patterns_s80
_patsX80 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s80
attach_T_Patterns (T_Patterns
arg_pats_))
         (T_Patterns_vOut79 [(FLabel, (FLabel, Direction), Bool)]
_patsIafs Patterns
_patsIcopy Patterns
_patsIself) = T_Patterns_s80 -> T_Patterns_v79
inv_Patterns_s80 T_Patterns_s80
_patsX80 (T_Patterns_vIn79
T_Patterns_vIn79 )
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule546 [(FLabel, (FLabel, Direction), Bool)]
_patsIafs
         _copy :: Pattern
_copy = Patterns -> Pos -> Pattern
rule547 Patterns
_patsIcopy Pos
arg_pos_
         _self :: Pattern
_self = Patterns -> Pos -> Pattern
rule548 Patterns
_patsIself Pos
arg_pos_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule549 Pattern
_copy
         _lhsOself :: Pattern
         _lhsOself :: Pattern
_lhsOself = forall a. a -> a
rule550 Pattern
_self
         __result_ :: T_Pattern_vOut76
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Pattern -> Pattern -> T_Pattern_vOut76
T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself
         in T_Pattern_vOut76
__result_ )
     in T_Pattern_v76 -> T_Pattern_s77
C_Pattern_s77 T_Pattern_v76
v76
   {-# INLINE rule546 #-}
   rule546 :: [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule546 = \ (([(FLabel, (FLabel, Direction), Bool)]
_patsIafs) :: [(FLabel, ALabel, Bool)]) ->
     [(FLabel, (FLabel, Direction), Bool)]
_patsIafs
   {-# INLINE rule547 #-}
   rule547 :: Patterns -> Pos -> Pattern
rule547 = \ ((Patterns
_patsIcopy) :: Patterns) Pos
pos_ ->
     Pos -> Patterns -> Pattern
Product Pos
pos_ Patterns
_patsIcopy
   {-# INLINE rule548 #-}
   rule548 :: Patterns -> Pos -> Pattern
rule548 = \ ((Patterns
_patsIself) :: Patterns) Pos
pos_ ->
     Pos -> Patterns -> Pattern
Product Pos
pos_ Patterns
_patsIself
   {-# INLINE rule549 #-}
   rule549 :: p -> p
rule549 = \ p
_copy ->
     p
_copy
   {-# INLINE rule550 #-}
   rule550 :: p -> p
rule550 = \ p
_self ->
     p
_self
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern  -> T_Pattern 
sem_Pattern_Alias :: NontermIdent -> NontermIdent -> T_Pattern -> T_Pattern
sem_Pattern_Alias NontermIdent
arg_field_ NontermIdent
arg_attr_ T_Pattern
arg_pat_ = Identity T_Pattern_s77 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s77
st77) where
   {-# NOINLINE st77 #-}
   st77 :: T_Pattern_s77
st77 = let
      v76 :: T_Pattern_v76 
      v76 :: T_Pattern_v76
v76 = \ (T_Pattern_vIn76
T_Pattern_vIn76 ) -> ( let
         _patX77 :: T_Pattern_s77
_patX77 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s77
attach_T_Pattern (T_Pattern
arg_pat_))
         (T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_patIafs Pattern
_patIcopy Pattern
_patIself) = T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 T_Pattern_s77
_patX77 (T_Pattern_vIn76
T_Pattern_vIn76 )
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = [(FLabel, (FLabel, Direction), Bool)]
-> NontermIdent
-> NontermIdent
-> [(FLabel, (FLabel, Direction), Bool)]
rule551 [(FLabel, (FLabel, Direction), Bool)]
_patIafs NontermIdent
arg_attr_ NontermIdent
arg_field_
         _copy :: Pattern
_copy = Pattern -> NontermIdent -> NontermIdent -> Pattern
rule552 Pattern
_patIcopy NontermIdent
arg_attr_ NontermIdent
arg_field_
         _self :: Pattern
_self = Pattern -> NontermIdent -> NontermIdent -> Pattern
rule553 Pattern
_patIself NontermIdent
arg_attr_ NontermIdent
arg_field_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule554 Pattern
_copy
         _lhsOself :: Pattern
         _lhsOself :: Pattern
_lhsOself = forall a. a -> a
rule555 Pattern
_self
         __result_ :: T_Pattern_vOut76
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Pattern -> Pattern -> T_Pattern_vOut76
T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself
         in T_Pattern_vOut76
__result_ )
     in T_Pattern_v76 -> T_Pattern_s77
C_Pattern_s77 T_Pattern_v76
v76
   {-# INLINE rule551 #-}
   {-# LINE 260 "src-ag/LOAG/Prepare.ag" #-}
   rule551 = \ ((_patIafs) :: [(FLabel, ALabel, Bool)]) attr_ field_ ->
                {-# LINE 260 "src-ag/LOAG/Prepare.ag" #-}
                let isLocal = (field_ == _LOC || field_ == _INST)
                 in [(getName field_, (getName attr_, dlhs field_),
                      isLocal)] ++ _patIafs
                {-# LINE 4561 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule552 #-}
   rule552 = \ ((_patIcopy) :: Pattern) attr_ field_ ->
     Alias field_ attr_ _patIcopy
   {-# INLINE rule553 #-}
   rule553 = \ ((_patIself) :: Pattern) attr_ field_ ->
     Alias field_ attr_ _patIself
   {-# INLINE rule554 #-}
   rule554 = \ _copy ->
     _copy
   {-# INLINE rule555 #-}
   rule555 = \ _self ->
     _self
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern  -> T_Pattern 
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable T_Pattern
arg_pat_ = Identity T_Pattern_s77 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s77
st77) where
   {-# NOINLINE st77 #-}
   st77 :: T_Pattern_s77
st77 = let
      v76 :: T_Pattern_v76 
      v76 :: T_Pattern_v76
v76 = \ (T_Pattern_vIn76
T_Pattern_vIn76 ) -> ( let
         _patX77 :: T_Pattern_s77
_patX77 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s77
attach_T_Pattern (T_Pattern
arg_pat_))
         (T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_patIafs Pattern
_patIcopy Pattern
_patIself) = T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 T_Pattern_s77
_patX77 (T_Pattern_vIn76
T_Pattern_vIn76 )
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule556 [(FLabel, (FLabel, Direction), Bool)]
_patIafs
         _copy :: Pattern
_copy = Pattern -> Pattern
rule557 Pattern
_patIcopy
         _self :: Pattern
_self = Pattern -> Pattern
rule558 Pattern
_patIself
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule559 Pattern
_copy
         _lhsOself :: Pattern
         _lhsOself :: Pattern
_lhsOself = forall a. a -> a
rule560 Pattern
_self
         __result_ :: T_Pattern_vOut76
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Pattern -> Pattern -> T_Pattern_vOut76
T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself
         in T_Pattern_vOut76
__result_ )
     in T_Pattern_v76 -> T_Pattern_s77
C_Pattern_s77 T_Pattern_v76
v76
   {-# INLINE rule556 #-}
   rule556 :: [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule556 = \ (([(FLabel, (FLabel, Direction), Bool)]
_patIafs) :: [(FLabel, ALabel, Bool)]) ->
     [(FLabel, (FLabel, Direction), Bool)]
_patIafs
   {-# INLINE rule557 #-}
   rule557 :: Pattern -> Pattern
rule557 = \ ((Pattern
_patIcopy) :: Pattern) ->
     Pattern -> Pattern
Irrefutable Pattern
_patIcopy
   {-# INLINE rule558 #-}
   rule558 :: Pattern -> Pattern
rule558 = \ ((Pattern
_patIself) :: Pattern) ->
     Pattern -> Pattern
Irrefutable Pattern
_patIself
   {-# INLINE rule559 #-}
   rule559 :: p -> p
rule559 = \ p
_copy ->
     p
_copy
   {-# INLINE rule560 #-}
   rule560 :: p -> p
rule560 = \ p
_self ->
     p
_self
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern 
sem_Pattern_Underscore :: Pos -> T_Pattern
sem_Pattern_Underscore Pos
arg_pos_ = Identity T_Pattern_s77 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s77
st77) where
   {-# NOINLINE st77 #-}
   st77 :: T_Pattern_s77
st77 = let
      v76 :: T_Pattern_v76 
      v76 :: T_Pattern_v76
v76 = \ (T_Pattern_vIn76
T_Pattern_vIn76 ) -> ( let
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = forall {a}. () -> [a]
rule561  ()
         _copy :: Pattern
_copy = Pos -> Pattern
rule562 Pos
arg_pos_
         _self :: Pattern
_self = Pos -> Pattern
rule563 Pos
arg_pos_
         _lhsOcopy :: Pattern
         _lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule564 Pattern
_copy
         _lhsOself :: Pattern
         _lhsOself :: Pattern
_lhsOself = forall a. a -> a
rule565 Pattern
_self
         __result_ :: T_Pattern_vOut76
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Pattern -> Pattern -> T_Pattern_vOut76
T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Pattern
_lhsOcopy Pattern
_lhsOself
         in T_Pattern_vOut76
__result_ )
     in T_Pattern_v76 -> T_Pattern_s77
C_Pattern_s77 T_Pattern_v76
v76
   {-# INLINE rule561 #-}
   rule561 :: () -> [a]
rule561 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule562 #-}
   rule562 :: Pos -> Pattern
rule562 = \ Pos
pos_ ->
     Pos -> Pattern
Underscore Pos
pos_
   {-# INLINE rule563 #-}
   rule563 :: Pos -> Pattern
rule563 = \ Pos
pos_ ->
     Pos -> Pattern
Underscore Pos
pos_
   {-# INLINE rule564 #-}
   rule564 :: p -> p
rule564 = \ p
_copy ->
     p
_copy
   {-# INLINE rule565 #-}
   rule565 :: p -> p
rule565 = \ p
_self ->
     p
_self

-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns  = Inh_Patterns {  }
data Syn_Patterns  = Syn_Patterns { Syn_Patterns -> [(FLabel, (FLabel, Direction), Bool)]
afs_Syn_Patterns :: ([(FLabel, ALabel, Bool)]), Syn_Patterns -> Patterns
copy_Syn_Patterns :: (Patterns), Syn_Patterns -> Patterns
self_Syn_Patterns :: (Patterns) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns  -> Inh_Patterns  -> (Syn_Patterns )
wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns
wrap_Patterns (T_Patterns Identity T_Patterns_s80
act) (Inh_Patterns
Inh_Patterns ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Patterns_s80
sem <- Identity T_Patterns_s80
act
        let arg79 :: T_Patterns_vIn79
arg79 = T_Patterns_vIn79
T_Patterns_vIn79 
        (T_Patterns_vOut79 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Patterns
_lhsOcopy Patterns
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Patterns_s80 -> T_Patterns_v79
inv_Patterns_s80 T_Patterns_s80
sem T_Patterns_vIn79
arg79)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([(FLabel, (FLabel, Direction), Bool)]
-> Patterns -> Patterns -> Syn_Patterns
Syn_Patterns [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Patterns
_lhsOcopy Patterns
_lhsOself)
   )

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

-- semantic domain
newtype T_Patterns  = T_Patterns {
                                 T_Patterns -> Identity T_Patterns_s80
attach_T_Patterns :: Identity (T_Patterns_s80 )
                                 }
newtype T_Patterns_s80  = C_Patterns_s80 {
                                         T_Patterns_s80 -> T_Patterns_v79
inv_Patterns_s80 :: (T_Patterns_v79 )
                                         }
data T_Patterns_s81  = C_Patterns_s81
type T_Patterns_v79  = (T_Patterns_vIn79 ) -> (T_Patterns_vOut79 )
data T_Patterns_vIn79  = T_Patterns_vIn79 
data T_Patterns_vOut79  = T_Patterns_vOut79 ([(FLabel, ALabel, Bool)]) (Patterns) (Patterns)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern  -> T_Patterns  -> T_Patterns 
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons T_Pattern
arg_hd_ T_Patterns
arg_tl_ = Identity T_Patterns_s80 -> T_Patterns
T_Patterns (forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s80
st80) where
   {-# NOINLINE st80 #-}
   st80 :: T_Patterns_s80
st80 = let
      v79 :: T_Patterns_v79 
      v79 :: T_Patterns_v79
v79 = \ (T_Patterns_vIn79
T_Patterns_vIn79 ) -> ( let
         _hdX77 :: T_Pattern_s77
_hdX77 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s77
attach_T_Pattern (T_Pattern
arg_hd_))
         _tlX80 :: T_Patterns_s80
_tlX80 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s80
attach_T_Patterns (T_Patterns
arg_tl_))
         (T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_hdIafs Pattern
_hdIcopy Pattern
_hdIself) = T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 T_Pattern_s77
_hdX77 (T_Pattern_vIn76
T_Pattern_vIn76 )
         (T_Patterns_vOut79 [(FLabel, (FLabel, Direction), Bool)]
_tlIafs Patterns
_tlIcopy Patterns
_tlIself) = T_Patterns_s80 -> T_Patterns_v79
inv_Patterns_s80 T_Patterns_s80
_tlX80 (T_Patterns_vIn79
T_Patterns_vIn79 )
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule566 [(FLabel, (FLabel, Direction), Bool)]
_hdIafs [(FLabel, (FLabel, Direction), Bool)]
_tlIafs
         _copy :: Patterns
_copy = Pattern -> Patterns -> Patterns
rule567 Pattern
_hdIcopy Patterns
_tlIcopy
         _self :: Patterns
_self = Pattern -> Patterns -> Patterns
rule568 Pattern
_hdIself Patterns
_tlIself
         _lhsOcopy :: Patterns
         _lhsOcopy :: Patterns
_lhsOcopy = forall a. a -> a
rule569 Patterns
_copy
         _lhsOself :: Patterns
         _lhsOself :: Patterns
_lhsOself = forall a. a -> a
rule570 Patterns
_self
         __result_ :: T_Patterns_vOut79
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Patterns -> Patterns -> T_Patterns_vOut79
T_Patterns_vOut79 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Patterns
_lhsOcopy Patterns
_lhsOself
         in T_Patterns_vOut79
__result_ )
     in T_Patterns_v79 -> T_Patterns_s80
C_Patterns_s80 T_Patterns_v79
v79
   {-# INLINE rule566 #-}
   rule566 :: [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
-> [(FLabel, (FLabel, Direction), Bool)]
rule566 = \ (([(FLabel, (FLabel, Direction), Bool)]
_hdIafs) :: [(FLabel, ALabel, Bool)]) (([(FLabel, (FLabel, Direction), Bool)]
_tlIafs) :: [(FLabel, ALabel, Bool)]) ->
     [(FLabel, (FLabel, Direction), Bool)]
_hdIafs forall a. [a] -> [a] -> [a]
++ [(FLabel, (FLabel, Direction), Bool)]
_tlIafs
   {-# INLINE rule567 #-}
   rule567 :: Pattern -> Patterns -> Patterns
rule567 = \ ((Pattern
_hdIcopy) :: Pattern) ((Patterns
_tlIcopy) :: Patterns) ->
     (:) Pattern
_hdIcopy Patterns
_tlIcopy
   {-# INLINE rule568 #-}
   rule568 :: Pattern -> Patterns -> Patterns
rule568 = \ ((Pattern
_hdIself) :: Pattern) ((Patterns
_tlIself) :: Patterns) ->
     (:) Pattern
_hdIself Patterns
_tlIself
   {-# INLINE rule569 #-}
   rule569 :: p -> p
rule569 = \ p
_copy ->
     p
_copy
   {-# INLINE rule570 #-}
   rule570 :: p -> p
rule570 = \ p
_self ->
     p
_self
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil ::  T_Patterns 
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil  = Identity T_Patterns_s80 -> T_Patterns
T_Patterns (forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s80
st80) where
   {-# NOINLINE st80 #-}
   st80 :: T_Patterns_s80
st80 = let
      v79 :: T_Patterns_v79 
      v79 :: T_Patterns_v79
v79 = \ (T_Patterns_vIn79
T_Patterns_vIn79 ) -> ( let
         _lhsOafs :: [(FLabel, ALabel, Bool)]
         _lhsOafs :: [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs = forall {a}. () -> [a]
rule571  ()
         _copy :: [a]
_copy = forall {a}. () -> [a]
rule572  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule573  ()
         _lhsOcopy :: Patterns
         _lhsOcopy :: Patterns
_lhsOcopy = forall a. a -> a
rule574 forall a. [a]
_copy
         _lhsOself :: Patterns
         _lhsOself :: Patterns
_lhsOself = forall a. a -> a
rule575 forall a. [a]
_self
         __result_ :: T_Patterns_vOut79
__result_ = [(FLabel, (FLabel, Direction), Bool)]
-> Patterns -> Patterns -> T_Patterns_vOut79
T_Patterns_vOut79 [(FLabel, (FLabel, Direction), Bool)]
_lhsOafs Patterns
_lhsOcopy Patterns
_lhsOself
         in T_Patterns_vOut79
__result_ )
     in T_Patterns_v79 -> T_Patterns_s80
C_Patterns_s80 T_Patterns_v79
v79
   {-# INLINE rule571 #-}
   rule571 :: () -> [a]
rule571 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule572 #-}
   rule572 :: () -> [a]
rule572 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule573 #-}
   rule573 :: () -> [a]
rule573 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule574 #-}
   rule574 :: p -> p
rule574 = \ p
_copy ->
     p
_copy
   {-# INLINE rule575 #-}
   rule575 :: p -> p
rule575 = \ p
_self ->
     p
_self

-- Production --------------------------------------------------
-- wrapper
data Inh_Production  = Inh_Production { Inh_Production -> MyType -> MyAttributes
ain_Inh_Production :: (MyType -> MyAttributes), Inh_Production -> MyType -> MyAttributes
an_Inh_Production :: (MyType -> MyAttributes), Inh_Production -> Map NontermIdent (Map NontermIdent [Expression])
aroundMap_Inh_Production :: (Map ConstructorIdent (Map Identifier [Expression])), Inh_Production -> MyType -> MyAttributes
asn_Inh_Production :: (MyType -> MyAttributes), Inh_Production -> Map NontermIdent (Set Dependency)
augM_Inh_Production :: (Map.Map Identifier (Set.Set Dependency)), Inh_Production -> MyType
dty_Inh_Production :: (MyType), Inh_Production -> Int
flab_Inh_Production :: (Int), Inh_Production -> FTY
fty_Inh_Production :: (FTY), Inh_Production -> FTY
ftyf_Inh_Production :: (FTY), Inh_Production -> HOMap
hoMapf_Inh_Production :: (HOMap), Inh_Production -> SF_P
lfpf_Inh_Production :: (SF_P), Inh_Production
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
mergeMap_Inh_Production :: (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))), Inh_Production -> [MySegment]
mysegments_Inh_Production :: (MySegments), Inh_Production -> NMP
nmp_Inh_Production :: (NMP), Inh_Production -> NMP_R
nmprf_Inh_Production :: (NMP_R), Inh_Production -> Int
olab_Inh_Production :: (Int), Inh_Production -> Options
options_Inh_Production :: (Options), Inh_Production -> PMP
pmpf_Inh_Production :: (PMP), Inh_Production -> PMP_R
pmprf_Inh_Production :: (PMP_R), Inh_Production -> [Edge]
res_ads_Inh_Production :: ([Edge]), Inh_Production -> Int
rulenumber_Inh_Production :: (Int), Inh_Production -> TDPRes
tdp_Inh_Production :: (TDPRes), Inh_Production -> IntMap Int
visMapf_Inh_Production :: (IMap.IntMap Int), Inh_Production -> Int
visitnum_Inh_Production :: (Int) }
data Syn_Production  = Syn_Production { Syn_Production -> [Edge]
ads_Syn_Production :: ([Edge]), Syn_Production -> A_P
ap_Syn_Production :: (A_P), Syn_Production -> EProductions
eprods_Syn_Production :: (EProductions), Syn_Production -> Map NontermIdent (Set Dependency)
fdps_Syn_Production :: (Map.Map ConstructorIdent (Set Dependency)), Syn_Production -> FMap
fieldMap_Syn_Production :: (FMap), Syn_Production -> Int
flab_Syn_Production :: (Int), Syn_Production -> Map PLabel [(PLabel, FLabel)]
fsInP_Syn_Production :: (FsInP), Syn_Production -> FTY
fty_Syn_Production :: (FTY), Syn_Production -> Map Int Int
gen_Syn_Production :: (Map Int Int), Syn_Production -> HOMap
hoMap_Syn_Production :: (HOMap), Syn_Production -> Map Int [Int]
inss_Syn_Production :: (Map Int [Int]), Syn_Production -> SF_P
lfp_Syn_Production :: (SF_P), Syn_Production -> SF_P
lfpr_Syn_Production :: (SF_P), Syn_Production -> Map NontermIdent (Map NontermIdent Type)
localSigMap_Syn_Production :: (Map.Map ConstructorIdent (Map.Map Identifier Type)), Syn_Production -> [Edge]
ofld_Syn_Production :: ([(Int, Int)]), Syn_Production -> Int
olab_Syn_Production :: (Int), Syn_Production -> PMP
pmp_Syn_Production :: (PMP), Syn_Production -> PMP_R
pmpr_Syn_Production :: (PMP_R), Syn_Production -> PLabel
ps_Syn_Production :: (PLabel), Syn_Production -> Set NontermIdent
refHoNts_Syn_Production :: (Set NontermIdent), Syn_Production -> Set NontermIdent
refNts_Syn_Production :: (Set NontermIdent), Syn_Production -> Map MyOccurrence NontermIdent
ruleMap_Syn_Production :: (Map.Map MyOccurrence Identifier), Syn_Production -> Int
rulenumber_Syn_Production :: (Int), Syn_Production -> Production
self_Syn_Production :: (Production), Syn_Production -> SF_P
sfp_Syn_Production :: (SF_P), Syn_Production -> Int
visitnum_Syn_Production :: (Int) }
{-# INLINABLE wrap_Production #-}
wrap_Production :: T_Production  -> Inh_Production  -> (Syn_Production )
wrap_Production :: T_Production -> Inh_Production -> Syn_Production
wrap_Production (T_Production Identity T_Production_s83
act) (Inh_Production MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Production_s83
sem <- Identity T_Production_s83
act
        let arg82 :: T_Production_vIn82
arg82 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent (Map NontermIdent [Expression])
-> (MyType -> MyAttributes)
-> Map NontermIdent (Set Dependency)
-> MyType
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> [MySegment]
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> TDPRes
-> IntMap Int
-> Int
-> T_Production_vIn82
T_Production_vIn82 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum
        (T_Production_vOut82 [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr PLabel
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Production
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Production_s83 -> T_Production_v82
inv_Production_s83 T_Production_s83
sem T_Production_vIn82
arg82)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([Edge]
-> A_P
-> EProductions
-> Map NontermIdent (Set Dependency)
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> PLabel
-> Set NontermIdent
-> Set NontermIdent
-> Map MyOccurrence NontermIdent
-> Int
-> Production
-> SF_P
-> Int
-> Syn_Production
Syn_Production [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr PLabel
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Production
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum)
   )

-- cata
{-# INLINE sem_Production #-}
sem_Production :: Production  -> T_Production 
sem_Production :: Production -> T_Production
sem_Production ( Production NontermIdent
con_ [NontermIdent]
params_ [Type]
constraints_ Children
children_ Rules
rules_ TypeSigs
typeSigs_ MaybeMacro
macro_  ) = NontermIdent
-> [NontermIdent]
-> [Type]
-> T_Children
-> T_Rules
-> T_TypeSigs
-> MaybeMacro
-> T_Production
sem_Production_Production NontermIdent
con_ [NontermIdent]
params_ [Type]
constraints_ ( Children -> T_Children
sem_Children Children
children_ ) ( Rules -> T_Rules
sem_Rules Rules
rules_ ) ( TypeSigs -> T_TypeSigs
sem_TypeSigs TypeSigs
typeSigs_ ) MaybeMacro
macro_ 

-- semantic domain
newtype T_Production  = T_Production {
                                     T_Production -> Identity T_Production_s83
attach_T_Production :: Identity (T_Production_s83 )
                                     }
newtype T_Production_s83  = C_Production_s83 {
                                             T_Production_s83 -> T_Production_v82
inv_Production_s83 :: (T_Production_v82 )
                                             }
data T_Production_s84  = C_Production_s84
type T_Production_v82  = (T_Production_vIn82 ) -> (T_Production_vOut82 )
data T_Production_vIn82  = T_Production_vIn82 (MyType -> MyAttributes) (MyType -> MyAttributes) (Map ConstructorIdent (Map Identifier [Expression])) (MyType -> MyAttributes) (Map.Map Identifier (Set.Set Dependency)) (MyType) (Int) (FTY) (FTY) (HOMap) (SF_P) (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))) (MySegments) (NMP) (NMP_R) (Int) (Options) (PMP) (PMP_R) ([Edge]) (Int) (TDPRes) (IMap.IntMap Int) (Int)
data T_Production_vOut82  = T_Production_vOut82 ([Edge]) (A_P) (EProductions) (Map.Map ConstructorIdent (Set Dependency)) (FMap) (Int) (FsInP) (FTY) (Map Int Int) (HOMap) (Map Int [Int]) (SF_P) (SF_P) (Map.Map ConstructorIdent (Map.Map Identifier Type)) ([(Int, Int)]) (Int) (PMP) (PMP_R) (PLabel) (Set NontermIdent) (Set NontermIdent) (Map.Map MyOccurrence Identifier) (Int) (Production) (SF_P) (Int)
{-# NOINLINE sem_Production_Production #-}
sem_Production_Production :: (ConstructorIdent) -> ([Identifier]) -> ([Type]) -> T_Children  -> T_Rules  -> T_TypeSigs  -> (MaybeMacro) ->  T_Production 
sem_Production_Production :: NontermIdent
-> [NontermIdent]
-> [Type]
-> T_Children
-> T_Rules
-> T_TypeSigs
-> MaybeMacro
-> T_Production
sem_Production_Production NontermIdent
arg_con_ [NontermIdent]
arg_params_ [Type]
arg_constraints_ T_Children
arg_children_ T_Rules
arg_rules_ T_TypeSigs
arg_typeSigs_ MaybeMacro
arg_macro_  = Identity T_Production_s83 -> T_Production
T_Production (forall (m :: * -> *) a. Monad m => a -> m a
return T_Production_s83
st83) where
   {-# NOINLINE st83 #-}
   st83 :: T_Production_s83
st83 = let
      v82 :: T_Production_v82 
      v82 :: T_Production_v82
v82 = \ (T_Production_vIn82 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _childrenX38 :: T_Children_s38
_childrenX38 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s38
attach_T_Children (T_Children
arg_children_))
         _rulesX92 :: T_Rules_s92
_rulesX92 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s92
attach_T_Rules (T_Rules
arg_rules_))
         _typeSigsX101 :: T_TypeSigs_s101
_typeSigsX101 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s101
attach_T_TypeSigs (T_TypeSigs
arg_typeSigs_))
         _segsX68 :: T_MySegments_s68
_segsX68 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_MySegments -> Identity T_MySegments_s68
attach_T_MySegments (([MySegment] -> T_MySegments
sem_MySegments [MySegment]
segs_val_)))
         (T_Children_vOut37 A_P
_childrenIap EChildren
_childrenIechilds FMap
_childrenIfieldMap Int
_childrenIflab FTY
_childrenIfty Map Int Int
_childrenIgen HOMap
_childrenIhoMap Map Int [Int]
_childrenIinss [Edge]
_childrenIofld Int
_childrenIolab PMP
_childrenIpmp PMP_R
_childrenIpmpr Set FLabel
_childrenIpts Set NontermIdent
_childrenIrefHoNts Set NontermIdent
_childrenIrefNts Children
_childrenIself) = T_Children_s38 -> T_Children_v37
inv_Children_s38 T_Children_s38
_childrenX38 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent [Expression]
-> (MyType -> MyAttributes)
-> MyType
-> Int
-> FTY
-> HOMap
-> SF_P
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
-> Set NontermIdent
-> NMP
-> NMP_R
-> Int
-> Options
-> PLabel
-> PMP
-> PMP_R
-> T_Children_vIn37
T_Children_vIn37 MyType -> MyAttributes
_childrenOain MyType -> MyAttributes
_childrenOan Map NontermIdent [Expression]
_childrenOaroundMap MyType -> MyAttributes
_childrenOasn MyType
_childrenOdty Int
_childrenOflab FTY
_childrenOfty HOMap
_childrenOhoMapf SF_P
_childrenOlfpf Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_childrenOmergeMap Set NontermIdent
_childrenOmergedChildren NMP
_childrenOnmp NMP_R
_childrenOnmprf Int
_childrenOolab Options
_childrenOoptions PLabel
_childrenOpll PMP
_childrenOpmpf PMP_R
_childrenOpmprf)
         (T_Rules_vOut91 ERules
_rulesIerules SF_P
_rulesIlfp SF_P
_rulesIlfpr Map MyOccurrence NontermIdent
_rulesIruleMap Int
_rulesIrulenumber Rules
_rulesIself SF_P
_rulesIsfp Set MyOccurrence
_rulesIusedLocals) = T_Rules_s92 -> T_Rules_v91
inv_Rules_s92 T_Rules_s92
_rulesX92 (MyType -> SF_P -> PLabel -> Set FLabel -> Int -> T_Rules_vIn91
T_Rules_vIn91 MyType
_rulesOdty SF_P
_rulesOlfpf PLabel
_rulesOpll Set FLabel
_rulesOpts Int
_rulesOrulenumber)
         (T_TypeSigs_vOut100 Map NontermIdent Type
_typeSigsIlocalSigMap TypeSigs
_typeSigsIself) = T_TypeSigs_s101 -> T_TypeSigs_v100
inv_TypeSigs_s101 T_TypeSigs_s101
_typeSigsX101 (T_TypeSigs_vIn100
T_TypeSigs_vIn100 )
         (T_MySegments_vOut67 Visits
_segsIevisits [MySegment]
_segsIself Int
_segsIvisitnum) = T_MySegments_s68 -> T_MySegments_v67
inv_MySegments_s68 T_MySegments_s68
_segsX68 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> (Set MyOccurrence, Set FLabel, Set NontermIdent,
    Set (FLabel, Int))
-> FTY
-> HOMap
-> SF_P
-> NMP
-> NMP_R
-> Options
-> PMP
-> PMP_R
-> PLabel
-> Map MyOccurrence NontermIdent
-> TDPRes
-> IntMap Int
-> Int
-> T_MySegments_vIn67
T_MySegments_vIn67 MyType -> MyAttributes
_segsOain MyType -> MyAttributes
_segsOasn forall {a} {a} {a} {a}. (Set a, Set a, Set a, Set a)
_segsOdone FTY
_segsOfty HOMap
_segsOhoMapf SF_P
_segsOlfpf NMP
_segsOnmp NMP_R
_segsOnmprf Options
_segsOoptions PMP
_segsOpmpf PMP_R
_segsOpmprf PLabel
_segsOps Map MyOccurrence NontermIdent
_segsOruleMap TDPRes
_segsOtdp IntMap Int
_segsOvisMapf Int
_segsOvisitnum)
         _aroundMap :: Map NontermIdent [Expression]
_aroundMap = Map NontermIdent (Map NontermIdent [Expression])
-> NontermIdent -> Map NontermIdent [Expression]
rule576 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap NontermIdent
arg_con_
         _mergeMap :: Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_mergeMap = Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> NontermIdent
-> Map NontermIdent (NontermIdent, [NontermIdent], Expression)
rule577 Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap NontermIdent
arg_con_
         _mergedChildren :: Set NontermIdent
_mergedChildren = forall {k} {a} {c}.
Map k (a, [NontermIdent], c) -> Set NontermIdent
rule578 Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_mergeMap
         _lhsOlocalSigMap :: Map.Map ConstructorIdent (Map.Map Identifier Type)
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap = forall {k}.
Map NontermIdent Type -> k -> Map k (Map NontermIdent Type)
rule579 Map NontermIdent Type
_typeSigsIlocalSigMap NontermIdent
arg_con_
         _ps :: PLabel
_ps = MyType -> NontermIdent -> PLabel
rule580 MyType
_lhsIdty NontermIdent
arg_con_
         _lhsOads :: [Edge]
         _lhsOads :: [Edge]
_lhsOads = PMP_R
-> Map NontermIdent (Set Dependency)
-> PLabel
-> NontermIdent
-> [Edge]
rule581 PMP_R
_childrenIpmpr Map NontermIdent (Set Dependency)
_lhsIaugM PLabel
_pll NontermIdent
arg_con_
         _childrenOdty :: MyType
_childrenOdty = MyType -> MyType
rule582 MyType
_lhsIdty
         _pll :: PLabel
_pll = MyType -> NontermIdent -> PLabel
rule583 MyType
_lhsIdty NontermIdent
arg_con_
         _rulesOpll :: PLabel
_rulesOpll = forall a. a -> a
rule584 PLabel
_pll
         _rulesOpts :: Set FLabel
_rulesOpts = Set FLabel -> Set FLabel
rule585 Set FLabel
_childrenIpts
         _lhsOfsInP :: FsInP
         _lhsOfsInP :: Map PLabel [(PLabel, FLabel)]
_lhsOfsInP = forall {k}. FMap -> k -> Map k [(PLabel, FLabel)]
rule586 FMap
_childrenIfieldMap PLabel
_pll
         _lhsOfdps :: Map.Map ConstructorIdent (Set Dependency)
         _lhsOfdps :: Map NontermIdent (Set Dependency)
_lhsOfdps = MyType
-> PMP
-> [Edge]
-> NontermIdent
-> Map NontermIdent (Set Dependency)
rule587 MyType
_lhsIdty PMP
_lhsIpmpf [Edge]
_lhsIres_ads NontermIdent
arg_con_
         _segsOruleMap :: Map MyOccurrence NontermIdent
_segsOruleMap = Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule588 Map MyOccurrence NontermIdent
_rulesIruleMap
         _segsOdone :: (Set a, Set a, Set a, Set a)
_segsOdone = forall {a} {a} {a} {a}. () -> (Set a, Set a, Set a, Set a)
rule589  ()
         _intros :: [VisitStep]
_intros = Children -> [VisitStep]
rule590 Children
_childrenIself
         _lhsOeprods :: EProductions
         _lhsOeprods :: EProductions
_lhsOeprods = EChildren
-> [VisitStep]
-> ERules
-> Visits
-> NontermIdent
-> [Type]
-> [NontermIdent]
-> EProductions
rule591 EChildren
_childrenIechilds [VisitStep]
_intros ERules
_rulesIerules Visits
_segsIevisits NontermIdent
arg_con_ [Type]
arg_constraints_ [NontermIdent]
arg_params_
         segs_val_ :: [MySegment]
segs_val_ = [MySegment] -> NMP -> PMP_R -> PLabel -> [MySegment]
rule592 [MySegment]
_lhsImysegments NMP
_lhsInmp PMP_R
_lhsIpmprf PLabel
_ps
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P
rule593 A_P
_childrenIap
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = FMap -> FMap
rule594 FMap
_childrenIfieldMap
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = FTY -> FTY
rule595 FTY
_childrenIfty
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int
rule596 Map Int Int
_childrenIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = HOMap -> HOMap
rule597 HOMap
_childrenIhoMap
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int]
rule598 Map Int [Int]
_childrenIinss
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = SF_P -> SF_P
rule599 SF_P
_rulesIlfp
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = SF_P -> SF_P
rule600 SF_P
_rulesIlfpr
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge]
rule601 [Edge]
_childrenIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP
rule602 PMP
_childrenIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R
rule603 PMP_R
_childrenIpmpr
         _lhsOrefHoNts :: Set NontermIdent
         _lhsOrefHoNts :: Set NontermIdent
_lhsOrefHoNts = Set NontermIdent -> Set NontermIdent
rule604 Set NontermIdent
_childrenIrefHoNts
         _lhsOrefNts :: Set NontermIdent
         _lhsOrefNts :: Set NontermIdent
_lhsOrefNts = Set NontermIdent -> Set NontermIdent
rule605 Set NontermIdent
_childrenIrefNts
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule606 Map MyOccurrence NontermIdent
_rulesIruleMap
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = SF_P -> SF_P
rule607 SF_P
_rulesIsfp
         _self :: Production
_self = Children
-> Rules
-> TypeSigs
-> NontermIdent
-> [Type]
-> MaybeMacro
-> [NontermIdent]
-> Production
rule608 Children
_childrenIself Rules
_rulesIself TypeSigs
_typeSigsIself NontermIdent
arg_con_ [Type]
arg_constraints_ MaybeMacro
arg_macro_ [NontermIdent]
arg_params_
         _lhsOself :: Production
         _lhsOself :: Production
_lhsOself = forall a. a -> a
rule609 Production
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule610 Int
_childrenIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule611 Int
_childrenIolab
         _lhsOps :: PLabel
         _lhsOps :: PLabel
_lhsOps = forall a. a -> a
rule612 PLabel
_ps
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule613 Int
_rulesIrulenumber
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule614 Int
_segsIvisitnum
         _childrenOain :: MyType -> MyAttributes
_childrenOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule615 MyType -> MyAttributes
_lhsIain
         _childrenOan :: MyType -> MyAttributes
_childrenOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule616 MyType -> MyAttributes
_lhsIan
         _childrenOaroundMap :: Map NontermIdent [Expression]
_childrenOaroundMap = forall a. a -> a
rule617 Map NontermIdent [Expression]
_aroundMap
         _childrenOasn :: MyType -> MyAttributes
_childrenOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule618 MyType -> MyAttributes
_lhsIasn
         _childrenOflab :: Int
_childrenOflab = Int -> Int
rule619 Int
_lhsIflab
         _childrenOfty :: FTY
_childrenOfty = FTY -> FTY
rule620 FTY
_lhsIfty
         _childrenOhoMapf :: HOMap
_childrenOhoMapf = HOMap -> HOMap
rule621 HOMap
_lhsIhoMapf
         _childrenOlfpf :: SF_P
_childrenOlfpf = SF_P -> SF_P
rule622 SF_P
_lhsIlfpf
         _childrenOmergeMap :: Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_childrenOmergeMap = forall a. a -> a
rule623 Map NontermIdent (NontermIdent, [NontermIdent], Expression)
_mergeMap
         _childrenOmergedChildren :: Set NontermIdent
_childrenOmergedChildren = forall a. a -> a
rule624 Set NontermIdent
_mergedChildren
         _childrenOnmp :: NMP
_childrenOnmp = NMP -> NMP
rule625 NMP
_lhsInmp
         _childrenOnmprf :: NMP_R
_childrenOnmprf = NMP_R -> NMP_R
rule626 NMP_R
_lhsInmprf
         _childrenOolab :: Int
_childrenOolab = Int -> Int
rule627 Int
_lhsIolab
         _childrenOoptions :: Options
_childrenOoptions = Options -> Options
rule628 Options
_lhsIoptions
         _childrenOpll :: PLabel
_childrenOpll = forall a. a -> a
rule629 PLabel
_pll
         _childrenOpmpf :: PMP
_childrenOpmpf = PMP -> PMP
rule630 PMP
_lhsIpmpf
         _childrenOpmprf :: PMP_R
_childrenOpmprf = PMP_R -> PMP_R
rule631 PMP_R
_lhsIpmprf
         _rulesOdty :: MyType
_rulesOdty = MyType -> MyType
rule632 MyType
_lhsIdty
         _rulesOlfpf :: SF_P
_rulesOlfpf = SF_P -> SF_P
rule633 SF_P
_lhsIlfpf
         _rulesOrulenumber :: Int
_rulesOrulenumber = Int -> Int
rule634 Int
_lhsIrulenumber
         _segsOain :: MyType -> MyAttributes
_segsOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule635 MyType -> MyAttributes
_lhsIain
         _segsOasn :: MyType -> MyAttributes
_segsOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule636 MyType -> MyAttributes
_lhsIasn
         _segsOfty :: FTY
_segsOfty = FTY -> FTY
rule637 FTY
_childrenIfty
         _segsOhoMapf :: HOMap
_segsOhoMapf = HOMap -> HOMap
rule638 HOMap
_lhsIhoMapf
         _segsOlfpf :: SF_P
_segsOlfpf = SF_P -> SF_P
rule639 SF_P
_lhsIlfpf
         _segsOnmp :: NMP
_segsOnmp = NMP -> NMP
rule640 NMP
_lhsInmp
         _segsOnmprf :: NMP_R
_segsOnmprf = NMP_R -> NMP_R
rule641 NMP_R
_lhsInmprf
         _segsOoptions :: Options
_segsOoptions = Options -> Options
rule642 Options
_lhsIoptions
         _segsOpmpf :: PMP
_segsOpmpf = PMP -> PMP
rule643 PMP
_lhsIpmpf
         _segsOpmprf :: PMP_R
_segsOpmprf = PMP_R -> PMP_R
rule644 PMP_R
_lhsIpmprf
         _segsOps :: PLabel
_segsOps = forall a. a -> a
rule645 PLabel
_ps
         _segsOtdp :: TDPRes
_segsOtdp = TDPRes -> TDPRes
rule646 TDPRes
_lhsItdp
         _segsOvisMapf :: IntMap Int
_segsOvisMapf = IntMap Int -> IntMap Int
rule647 IntMap Int
_lhsIvisMapf
         _segsOvisitnum :: Int
_segsOvisitnum = Int -> Int
rule648 Int
_lhsIvisitnum
         __result_ :: T_Production_vOut82
__result_ = [Edge]
-> A_P
-> EProductions
-> Map NontermIdent (Set Dependency)
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> PLabel
-> Set NontermIdent
-> Set NontermIdent
-> Map MyOccurrence NontermIdent
-> Int
-> Production
-> SF_P
-> Int
-> T_Production_vOut82
T_Production_vOut82 [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr PLabel
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Production
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum
         in T_Production_vOut82
__result_ )
     in T_Production_v82 -> T_Production_s83
C_Production_s83 T_Production_v82
v82
   {-# INLINE rule576 #-}
   {-# LINE 89 "src-ag/ExecutionPlanCommon.ag" #-}
   rule576 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) con_ ->
                                                 {-# LINE 89 "src-ag/ExecutionPlanCommon.ag" #-}
                                                 Map.findWithDefault Map.empty con_ _lhsIaroundMap
                                                 {-# LINE 4896 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule577 #-}
   {-# LINE 114 "src-ag/ExecutionPlanCommon.ag" #-}
   rule577 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))) con_ ->
                                                {-# LINE 114 "src-ag/ExecutionPlanCommon.ag" #-}
                                                Map.findWithDefault Map.empty con_ _lhsImergeMap
                                                {-# LINE 4902 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule578 #-}
   {-# LINE 120 "src-ag/ExecutionPlanCommon.ag" #-}
   rule578 = \ _mergeMap ->
                         {-# LINE 120 "src-ag/ExecutionPlanCommon.ag" #-}
                         Set.unions [ Set.fromList ms | (_,ms,_) <- Map.elems _mergeMap     ]
                         {-# LINE 4908 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule579 #-}
   {-# LINE 160 "src-ag/ExecutionPlanCommon.ag" #-}
   rule579 = \ ((_typeSigsIlocalSigMap) :: Map Identifier Type) con_ ->
                                                   {-# LINE 160 "src-ag/ExecutionPlanCommon.ag" #-}
                                                   Map.singleton con_ _typeSigsIlocalSigMap
                                                   {-# LINE 4914 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule580 #-}
   {-# LINE 115 "src-ag/LOAG/Prepare.ag" #-}
   rule580 = \ ((_lhsIdty) :: MyType) con_ ->
               {-# LINE 115 "src-ag/LOAG/Prepare.ag" #-}
               (_lhsIdty,getName con_)
               {-# LINE 4920 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule581 #-}
   {-# LINE 117 "src-ag/LOAG/Prepare.ag" #-}
   rule581 = \ ((_childrenIpmpr) :: PMP_R) ((_lhsIaugM) :: Map.Map Identifier (Set.Set Dependency)) _pll con_ ->
          {-# LINE 117 "src-ag/LOAG/Prepare.ag" #-}
          case Map.lookup con_ _lhsIaugM of
           Nothing -> []
           Just a  -> Set.toList $ Set.map (depToEdge _childrenIpmpr _pll    ) a
          {-# LINE 4928 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule582 #-}
   {-# LINE 120 "src-ag/LOAG/Prepare.ag" #-}
   rule582 = \ ((_lhsIdty) :: MyType) ->
                     {-# LINE 120 "src-ag/LOAG/Prepare.ag" #-}
                     _lhsIdty
                     {-# LINE 4934 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule583 #-}
   {-# LINE 214 "src-ag/LOAG/Prepare.ag" #-}
   rule583 = \ ((_lhsIdty) :: MyType) con_ ->
                  {-# LINE 214 "src-ag/LOAG/Prepare.ag" #-}
                  (_lhsIdty,getName con_)
                  {-# LINE 4940 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule584 #-}
   {-# LINE 215 "src-ag/LOAG/Prepare.ag" #-}
   rule584 = \ _pll ->
                  {-# LINE 215 "src-ag/LOAG/Prepare.ag" #-}
                  _pll
                  {-# LINE 4946 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule585 #-}
   {-# LINE 216 "src-ag/LOAG/Prepare.ag" #-}
   rule585 = \ ((_childrenIpts) :: Set.Set FLabel) ->
                  {-# LINE 216 "src-ag/LOAG/Prepare.ag" #-}
                  _childrenIpts
                  {-# LINE 4952 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule586 #-}
   {-# LINE 217 "src-ag/LOAG/Prepare.ag" #-}
   rule586 = \ ((_childrenIfieldMap) :: FMap) _pll ->
                  {-# LINE 217 "src-ag/LOAG/Prepare.ag" #-}
                  Map.singleton _pll $ Map.keys _childrenIfieldMap
                  {-# LINE 4958 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule587 #-}
   {-# LINE 89 "src-ag/LOAG/Order.ag" #-}
   rule587 = \ ((_lhsIdty) :: MyType) ((_lhsIpmpf) :: PMP) ((_lhsIres_ads) :: [Edge]) con_ ->
        {-# LINE 89 "src-ag/LOAG/Order.ag" #-}
        let op d@(f,t) ds
              | fst (argsOf $ findWithErr _lhsIpmpf "fdps" f) == (_lhsIdty,getName con_)
                  = Set.insert (edgeToDep _lhsIpmpf d) ds
              | otherwise
                  = ds
        in Map.singleton con_ $ foldr op Set.empty _lhsIres_ads
        {-# LINE 4969 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule588 #-}
   {-# LINE 167 "src-ag/LOAG/Order.ag" #-}
   rule588 = \ ((_rulesIruleMap) :: Map.Map MyOccurrence Identifier) ->
                          {-# LINE 167 "src-ag/LOAG/Order.ag" #-}
                          _rulesIruleMap
                          {-# LINE 4975 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule589 #-}
   {-# LINE 168 "src-ag/LOAG/Order.ag" #-}
   rule589 = \  (_ :: ()) ->
                          {-# LINE 168 "src-ag/LOAG/Order.ag" #-}
                          (Set.empty, Set.empty, Set.empty, Set.empty)
                          {-# LINE 4981 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule590 #-}
   {-# LINE 169 "src-ag/LOAG/Order.ag" #-}
   rule590 = \ ((_childrenIself) :: Children) ->
                        {-# LINE 169 "src-ag/LOAG/Order.ag" #-}
                        let intro (Child nm _ kind)
                              | kind == ChildAttr = Nothing
                              | otherwise = Just $ ChildIntro nm
                          in catMaybes $ map intro _childrenIself
                        {-# LINE 4990 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule591 #-}
   {-# LINE 174 "src-ag/LOAG/Order.ag" #-}
   rule591 = \ ((_childrenIechilds) :: EChildren) _intros ((_rulesIerules) :: ERules) ((_segsIevisits) :: Visits) con_ constraints_ params_ ->
              {-# LINE 174 "src-ag/LOAG/Order.ag" #-}
              let ((Visit ident from to inh syn steps kind):vss) = _segsIevisits
                  steps' = _intros     ++ steps
                  visits | null _segsIevisits = []
                         | otherwise =
                              ((Visit ident from to inh syn steps' kind):vss)
               in [EProduction
                          con_
                          params_
                          constraints_
                          _rulesIerules
                          _childrenIechilds
                          visits ]
              {-# LINE 5007 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule592 #-}
   {-# LINE 346 "src-ag/LOAG/Order.ag" #-}
   rule592 = \ ((_lhsImysegments) :: MySegments) ((_lhsInmp) :: NMP) ((_lhsIpmprf) :: PMP_R) _ps ->
              {-# LINE 346 "src-ag/LOAG/Order.ag" #-}
              map (\(MySegment visnr inhs syns _ _) ->
                     MySegment visnr inhs syns
                               (Just $ map (_lhsIpmprf Map.!) $
                                      handAllOut (_ps    ,"lhs") $
                                          map (_lhsInmp Map.!) inhs)
                               (Just $ map (_lhsIpmprf Map.!) $
                                      handAllOut (_ps    ,"lhs") $
                                          map (_lhsInmp Map.!) syns)
                           ) _lhsImysegments
              {-# LINE 5021 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule593 #-}
   rule593 = \ ((_childrenIap) :: A_P) ->
     _childrenIap
   {-# INLINE rule594 #-}
   rule594 = \ ((_childrenIfieldMap) :: FMap) ->
     _childrenIfieldMap
   {-# INLINE rule595 #-}
   rule595 = \ ((_childrenIfty) :: FTY) ->
     _childrenIfty
   {-# INLINE rule596 #-}
   rule596 = \ ((_childrenIgen) :: Map Int Int) ->
     _childrenIgen
   {-# INLINE rule597 #-}
   rule597 = \ ((_childrenIhoMap) :: HOMap) ->
     _childrenIhoMap
   {-# INLINE rule598 #-}
   rule598 = \ ((_childrenIinss) :: Map Int [Int]) ->
     _childrenIinss
   {-# INLINE rule599 #-}
   rule599 = \ ((_rulesIlfp) :: SF_P) ->
     _rulesIlfp
   {-# INLINE rule600 #-}
   rule600 = \ ((_rulesIlfpr) :: SF_P) ->
     _rulesIlfpr
   {-# INLINE rule601 #-}
   rule601 = \ ((_childrenIofld) :: [(Int, Int)]) ->
     _childrenIofld
   {-# INLINE rule602 #-}
   rule602 = \ ((_childrenIpmp) :: PMP) ->
     _childrenIpmp
   {-# INLINE rule603 #-}
   rule603 = \ ((_childrenIpmpr) :: PMP_R) ->
     _childrenIpmpr
   {-# INLINE rule604 #-}
   rule604 = \ ((_childrenIrefHoNts) :: Set NontermIdent) ->
     _childrenIrefHoNts
   {-# INLINE rule605 #-}
   rule605 = \ ((_childrenIrefNts) :: Set NontermIdent) ->
     _childrenIrefNts
   {-# INLINE rule606 #-}
   rule606 = \ ((_rulesIruleMap) :: Map.Map MyOccurrence Identifier) ->
     _rulesIruleMap
   {-# INLINE rule607 #-}
   rule607 = \ ((_rulesIsfp) :: SF_P) ->
     _rulesIsfp
   {-# INLINE rule608 #-}
   rule608 = \ ((_childrenIself) :: Children) ((_rulesIself) :: Rules) ((_typeSigsIself) :: TypeSigs) con_ constraints_ macro_ params_ ->
     Production con_ params_ constraints_ _childrenIself _rulesIself _typeSigsIself macro_
   {-# INLINE rule609 #-}
   rule609 = \ _self ->
     _self
   {-# INLINE rule610 #-}
   rule610 = \ ((_childrenIflab) :: Int) ->
     _childrenIflab
   {-# INLINE rule611 #-}
   rule611 = \ ((_childrenIolab) :: Int) ->
     _childrenIolab
   {-# INLINE rule612 #-}
   rule612 = \ _ps ->
     _ps
   {-# INLINE rule613 #-}
   rule613 = \ ((_rulesIrulenumber) :: Int) ->
     _rulesIrulenumber
   {-# INLINE rule614 #-}
   rule614 = \ ((_segsIvisitnum) :: Int) ->
     _segsIvisitnum
   {-# INLINE rule615 #-}
   rule615 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule616 #-}
   rule616 = \ ((_lhsIan) :: MyType -> MyAttributes) ->
     _lhsIan
   {-# INLINE rule617 #-}
   rule617 = \ _aroundMap ->
     _aroundMap
   {-# INLINE rule618 #-}
   rule618 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule619 #-}
   rule619 = \ ((_lhsIflab) :: Int) ->
     _lhsIflab
   {-# INLINE rule620 #-}
   rule620 = \ ((_lhsIfty) :: FTY) ->
     _lhsIfty
   {-# INLINE rule621 #-}
   rule621 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule622 #-}
   rule622 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule623 #-}
   rule623 = \ _mergeMap ->
     _mergeMap
   {-# INLINE rule624 #-}
   rule624 = \ _mergedChildren ->
     _mergedChildren
   {-# INLINE rule625 #-}
   rule625 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule626 #-}
   rule626 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule627 #-}
   rule627 = \ ((_lhsIolab) :: Int) ->
     _lhsIolab
   {-# INLINE rule628 #-}
   rule628 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule629 #-}
   rule629 = \ _pll ->
     _pll
   {-# INLINE rule630 #-}
   rule630 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule631 #-}
   rule631 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule632 #-}
   rule632 = \ ((_lhsIdty) :: MyType) ->
     _lhsIdty
   {-# INLINE rule633 #-}
   rule633 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule634 #-}
   rule634 = \ ((_lhsIrulenumber) :: Int) ->
     _lhsIrulenumber
   {-# INLINE rule635 #-}
   rule635 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule636 #-}
   rule636 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule637 #-}
   rule637 = \ ((_childrenIfty) :: FTY) ->
     _childrenIfty
   {-# INLINE rule638 #-}
   rule638 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule639 #-}
   rule639 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule640 #-}
   rule640 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule641 #-}
   rule641 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule642 #-}
   rule642 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule643 #-}
   rule643 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule644 #-}
   rule644 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule645 #-}
   rule645 = \ _ps ->
     _ps
   {-# INLINE rule646 #-}
   rule646 = \ ((_lhsItdp) :: TDPRes) ->
     _lhsItdp
   {-# INLINE rule647 #-}
   rule647 = \ ((_lhsIvisMapf) :: IMap.IntMap Int) ->
     _lhsIvisMapf
   {-# INLINE rule648 #-}
   rule648 = \ ((_lhsIvisitnum) :: Int) ->
     _lhsIvisitnum

-- Productions -------------------------------------------------
-- wrapper
data Inh_Productions  = Inh_Productions { Inh_Productions -> MyType -> MyAttributes
ain_Inh_Productions :: (MyType -> MyAttributes), Inh_Productions -> MyType -> MyAttributes
an_Inh_Productions :: (MyType -> MyAttributes), Inh_Productions -> Map NontermIdent (Map NontermIdent [Expression])
aroundMap_Inh_Productions :: (Map ConstructorIdent (Map Identifier [Expression])), Inh_Productions -> MyType -> MyAttributes
asn_Inh_Productions :: (MyType -> MyAttributes), Inh_Productions -> Map NontermIdent (Set Dependency)
augM_Inh_Productions :: (Map.Map Identifier (Set.Set Dependency)), Inh_Productions -> MyType
dty_Inh_Productions :: (MyType), Inh_Productions -> Int
flab_Inh_Productions :: (Int), Inh_Productions -> FTY
fty_Inh_Productions :: (FTY), Inh_Productions -> FTY
ftyf_Inh_Productions :: (FTY), Inh_Productions -> HOMap
hoMapf_Inh_Productions :: (HOMap), Inh_Productions -> SF_P
lfpf_Inh_Productions :: (SF_P), Inh_Productions
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
mergeMap_Inh_Productions :: (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))), Inh_Productions -> [MySegment]
mysegments_Inh_Productions :: (MySegments), Inh_Productions -> NMP
nmp_Inh_Productions :: (NMP), Inh_Productions -> NMP_R
nmprf_Inh_Productions :: (NMP_R), Inh_Productions -> Int
olab_Inh_Productions :: (Int), Inh_Productions -> Options
options_Inh_Productions :: (Options), Inh_Productions -> PMP
pmpf_Inh_Productions :: (PMP), Inh_Productions -> PMP_R
pmprf_Inh_Productions :: (PMP_R), Inh_Productions -> [Edge]
res_ads_Inh_Productions :: ([Edge]), Inh_Productions -> Int
rulenumber_Inh_Productions :: (Int), Inh_Productions -> TDPRes
tdp_Inh_Productions :: (TDPRes), Inh_Productions -> IntMap Int
visMapf_Inh_Productions :: (IMap.IntMap Int), Inh_Productions -> Int
visitnum_Inh_Productions :: (Int) }
data Syn_Productions  = Syn_Productions { Syn_Productions -> [Edge]
ads_Syn_Productions :: ([Edge]), Syn_Productions -> A_P
ap_Syn_Productions :: (A_P), Syn_Productions -> EProductions
eprods_Syn_Productions :: (EProductions), Syn_Productions -> Map NontermIdent (Set Dependency)
fdps_Syn_Productions :: (Map.Map ConstructorIdent (Set Dependency)), Syn_Productions -> FMap
fieldMap_Syn_Productions :: (FMap), Syn_Productions -> Int
flab_Syn_Productions :: (Int), Syn_Productions -> Map PLabel [(PLabel, FLabel)]
fsInP_Syn_Productions :: (FsInP), Syn_Productions -> FTY
fty_Syn_Productions :: (FTY), Syn_Productions -> Map Int Int
gen_Syn_Productions :: (Map Int Int), Syn_Productions -> HOMap
hoMap_Syn_Productions :: (HOMap), Syn_Productions -> Map Int [Int]
inss_Syn_Productions :: (Map Int [Int]), Syn_Productions -> SF_P
lfp_Syn_Productions :: (SF_P), Syn_Productions -> SF_P
lfpr_Syn_Productions :: (SF_P), Syn_Productions -> Map NontermIdent (Map NontermIdent Type)
localSigMap_Syn_Productions :: (Map.Map ConstructorIdent (Map.Map Identifier Type)), Syn_Productions -> [Edge]
ofld_Syn_Productions :: ([(Int, Int)]), Syn_Productions -> Int
olab_Syn_Productions :: (Int), Syn_Productions -> PMP
pmp_Syn_Productions :: (PMP), Syn_Productions -> PMP_R
pmpr_Syn_Productions :: (PMP_R), Syn_Productions -> [PLabel]
ps_Syn_Productions :: ([PLabel]), Syn_Productions -> Set NontermIdent
refHoNts_Syn_Productions :: (Set NontermIdent), Syn_Productions -> Set NontermIdent
refNts_Syn_Productions :: (Set NontermIdent), Syn_Productions -> Map MyOccurrence NontermIdent
ruleMap_Syn_Productions :: (Map.Map MyOccurrence Identifier), Syn_Productions -> Int
rulenumber_Syn_Productions :: (Int), Syn_Productions -> Productions
self_Syn_Productions :: (Productions), Syn_Productions -> SF_P
sfp_Syn_Productions :: (SF_P), Syn_Productions -> Int
visitnum_Syn_Productions :: (Int) }
{-# INLINABLE wrap_Productions #-}
wrap_Productions :: T_Productions  -> Inh_Productions  -> (Syn_Productions )
wrap_Productions :: T_Productions -> Inh_Productions -> Syn_Productions
wrap_Productions (T_Productions Identity T_Productions_s86
act) (Inh_Productions MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Productions_s86
sem <- Identity T_Productions_s86
act
        let arg85 :: T_Productions_vIn85
arg85 = (MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent (Map NontermIdent [Expression])
-> (MyType -> MyAttributes)
-> Map NontermIdent (Set Dependency)
-> MyType
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> [MySegment]
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> TDPRes
-> IntMap Int
-> Int
-> T_Productions_vIn85
T_Productions_vIn85 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum
        (T_Productions_vOut85 [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Productions
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Productions_s86 -> T_Productions_v85
inv_Productions_s86 T_Productions_s86
sem T_Productions_vIn85
arg85)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([Edge]
-> A_P
-> EProductions
-> Map NontermIdent (Set Dependency)
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Set NontermIdent
-> Set NontermIdent
-> Map MyOccurrence NontermIdent
-> Int
-> Productions
-> SF_P
-> Int
-> Syn_Productions
Syn_Productions [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Productions
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum)
   )

-- cata
{-# NOINLINE sem_Productions #-}
sem_Productions :: Productions  -> T_Productions 
sem_Productions :: Productions -> T_Productions
sem_Productions Productions
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Production -> T_Productions -> T_Productions
sem_Productions_Cons T_Productions
sem_Productions_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Production -> T_Production
sem_Production Productions
list)

-- semantic domain
newtype T_Productions  = T_Productions {
                                       T_Productions -> Identity T_Productions_s86
attach_T_Productions :: Identity (T_Productions_s86 )
                                       }
newtype T_Productions_s86  = C_Productions_s86 {
                                               T_Productions_s86 -> T_Productions_v85
inv_Productions_s86 :: (T_Productions_v85 )
                                               }
data T_Productions_s87  = C_Productions_s87
type T_Productions_v85  = (T_Productions_vIn85 ) -> (T_Productions_vOut85 )
data T_Productions_vIn85  = T_Productions_vIn85 (MyType -> MyAttributes) (MyType -> MyAttributes) (Map ConstructorIdent (Map Identifier [Expression])) (MyType -> MyAttributes) (Map.Map Identifier (Set.Set Dependency)) (MyType) (Int) (FTY) (FTY) (HOMap) (SF_P) (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))) (MySegments) (NMP) (NMP_R) (Int) (Options) (PMP) (PMP_R) ([Edge]) (Int) (TDPRes) (IMap.IntMap Int) (Int)
data T_Productions_vOut85  = T_Productions_vOut85 ([Edge]) (A_P) (EProductions) (Map.Map ConstructorIdent (Set Dependency)) (FMap) (Int) (FsInP) (FTY) (Map Int Int) (HOMap) (Map Int [Int]) (SF_P) (SF_P) (Map.Map ConstructorIdent (Map.Map Identifier Type)) ([(Int, Int)]) (Int) (PMP) (PMP_R) ([PLabel]) (Set NontermIdent) (Set NontermIdent) (Map.Map MyOccurrence Identifier) (Int) (Productions) (SF_P) (Int)
{-# NOINLINE sem_Productions_Cons #-}
sem_Productions_Cons :: T_Production  -> T_Productions  -> T_Productions 
sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions
sem_Productions_Cons T_Production
arg_hd_ T_Productions
arg_tl_ = Identity T_Productions_s86 -> T_Productions
T_Productions (forall (m :: * -> *) a. Monad m => a -> m a
return T_Productions_s86
st86) where
   {-# NOINLINE st86 #-}
   st86 :: T_Productions_s86
st86 = let
      v85 :: T_Productions_v85 
      v85 :: T_Productions_v85
v85 = \ (T_Productions_vIn85 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _hdX83 :: T_Production_s83
_hdX83 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Production -> Identity T_Production_s83
attach_T_Production (T_Production
arg_hd_))
         _tlX86 :: T_Productions_s86
_tlX86 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s86
attach_T_Productions (T_Productions
arg_tl_))
         (T_Production_vOut82 [Edge]
_hdIads A_P
_hdIap EProductions
_hdIeprods Map NontermIdent (Set Dependency)
_hdIfdps FMap
_hdIfieldMap Int
_hdIflab Map PLabel [(PLabel, FLabel)]
_hdIfsInP FTY
_hdIfty Map Int Int
_hdIgen HOMap
_hdIhoMap Map Int [Int]
_hdIinss SF_P
_hdIlfp SF_P
_hdIlfpr Map NontermIdent (Map NontermIdent Type)
_hdIlocalSigMap [Edge]
_hdIofld Int
_hdIolab PMP
_hdIpmp PMP_R
_hdIpmpr PLabel
_hdIps Set NontermIdent
_hdIrefHoNts Set NontermIdent
_hdIrefNts Map MyOccurrence NontermIdent
_hdIruleMap Int
_hdIrulenumber Production
_hdIself SF_P
_hdIsfp Int
_hdIvisitnum) = T_Production_s83 -> T_Production_v82
inv_Production_s83 T_Production_s83
_hdX83 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent (Map NontermIdent [Expression])
-> (MyType -> MyAttributes)
-> Map NontermIdent (Set Dependency)
-> MyType
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> [MySegment]
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> TDPRes
-> IntMap Int
-> Int
-> T_Production_vIn82
T_Production_vIn82 MyType -> MyAttributes
_hdOain MyType -> MyAttributes
_hdOan Map NontermIdent (Map NontermIdent [Expression])
_hdOaroundMap MyType -> MyAttributes
_hdOasn Map NontermIdent (Set Dependency)
_hdOaugM MyType
_hdOdty Int
_hdOflab FTY
_hdOfty FTY
_hdOftyf HOMap
_hdOhoMapf SF_P
_hdOlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_hdOmergeMap [MySegment]
_hdOmysegments NMP
_hdOnmp NMP_R
_hdOnmprf Int
_hdOolab Options
_hdOoptions PMP
_hdOpmpf PMP_R
_hdOpmprf [Edge]
_hdOres_ads Int
_hdOrulenumber TDPRes
_hdOtdp IntMap Int
_hdOvisMapf Int
_hdOvisitnum)
         (T_Productions_vOut85 [Edge]
_tlIads A_P
_tlIap EProductions
_tlIeprods Map NontermIdent (Set Dependency)
_tlIfdps FMap
_tlIfieldMap Int
_tlIflab Map PLabel [(PLabel, FLabel)]
_tlIfsInP FTY
_tlIfty Map Int Int
_tlIgen HOMap
_tlIhoMap Map Int [Int]
_tlIinss SF_P
_tlIlfp SF_P
_tlIlfpr Map NontermIdent (Map NontermIdent Type)
_tlIlocalSigMap [Edge]
_tlIofld Int
_tlIolab PMP
_tlIpmp PMP_R
_tlIpmpr [PLabel]
_tlIps Set NontermIdent
_tlIrefHoNts Set NontermIdent
_tlIrefNts Map MyOccurrence NontermIdent
_tlIruleMap Int
_tlIrulenumber Productions
_tlIself SF_P
_tlIsfp Int
_tlIvisitnum) = T_Productions_s86 -> T_Productions_v85
inv_Productions_s86 T_Productions_s86
_tlX86 ((MyType -> MyAttributes)
-> (MyType -> MyAttributes)
-> Map NontermIdent (Map NontermIdent [Expression])
-> (MyType -> MyAttributes)
-> Map NontermIdent (Set Dependency)
-> MyType
-> Int
-> FTY
-> FTY
-> HOMap
-> SF_P
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> [MySegment]
-> NMP
-> NMP_R
-> Int
-> Options
-> PMP
-> PMP_R
-> [Edge]
-> Int
-> TDPRes
-> IntMap Int
-> Int
-> T_Productions_vIn85
T_Productions_vIn85 MyType -> MyAttributes
_tlOain MyType -> MyAttributes
_tlOan Map NontermIdent (Map NontermIdent [Expression])
_tlOaroundMap MyType -> MyAttributes
_tlOasn Map NontermIdent (Set Dependency)
_tlOaugM MyType
_tlOdty Int
_tlOflab FTY
_tlOfty FTY
_tlOftyf HOMap
_tlOhoMapf SF_P
_tlOlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_tlOmergeMap [MySegment]
_tlOmysegments NMP
_tlOnmp NMP_R
_tlOnmprf Int
_tlOolab Options
_tlOoptions PMP
_tlOpmpf PMP_R
_tlOpmprf [Edge]
_tlOres_ads Int
_tlOrulenumber TDPRes
_tlOtdp IntMap Int
_tlOvisMapf Int
_tlOvisitnum)
         _tlOvisitnum :: Int
_tlOvisitnum = Int -> Int
rule649 Int
_lhsIvisitnum
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule650 Int
_hdIvisitnum
         _lhsOads :: [Edge]
         _lhsOads :: [Edge]
_lhsOads = [Edge] -> [Edge] -> [Edge]
rule651 [Edge]
_hdIads [Edge]
_tlIads
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = A_P -> A_P -> A_P
rule652 A_P
_hdIap A_P
_tlIap
         _lhsOeprods :: EProductions
         _lhsOeprods :: EProductions
_lhsOeprods = EProductions -> EProductions -> EProductions
rule653 EProductions
_hdIeprods EProductions
_tlIeprods
         _lhsOfdps :: Map.Map ConstructorIdent (Set Dependency)
         _lhsOfdps :: Map NontermIdent (Set Dependency)
_lhsOfdps = Map NontermIdent (Set Dependency)
-> Map NontermIdent (Set Dependency)
-> Map NontermIdent (Set Dependency)
rule654 Map NontermIdent (Set Dependency)
_hdIfdps Map NontermIdent (Set Dependency)
_tlIfdps
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = FMap -> FMap -> FMap
rule655 FMap
_hdIfieldMap FMap
_tlIfieldMap
         _lhsOfsInP :: FsInP
         _lhsOfsInP :: Map PLabel [(PLabel, FLabel)]
_lhsOfsInP = Map PLabel [(PLabel, FLabel)]
-> Map PLabel [(PLabel, FLabel)] -> Map PLabel [(PLabel, FLabel)]
rule656 Map PLabel [(PLabel, FLabel)]
_hdIfsInP Map PLabel [(PLabel, FLabel)]
_tlIfsInP
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = FTY -> FTY -> FTY
rule657 FTY
_hdIfty FTY
_tlIfty
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = Map Int Int -> Map Int Int -> Map Int Int
rule658 Map Int Int
_hdIgen Map Int Int
_tlIgen
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = HOMap -> HOMap -> HOMap
rule659 HOMap
_hdIhoMap HOMap
_tlIhoMap
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = Map Int [Int] -> Map Int [Int] -> Map Int [Int]
rule660 Map Int [Int]
_hdIinss Map Int [Int]
_tlIinss
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = SF_P -> SF_P -> SF_P
rule661 SF_P
_hdIlfp SF_P
_tlIlfp
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = SF_P -> SF_P -> SF_P
rule662 SF_P
_hdIlfpr SF_P
_tlIlfpr
         _lhsOlocalSigMap :: Map.Map ConstructorIdent (Map.Map Identifier Type)
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap = Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
-> Map NontermIdent (Map NontermIdent Type)
rule663 Map NontermIdent (Map NontermIdent Type)
_hdIlocalSigMap Map NontermIdent (Map NontermIdent Type)
_tlIlocalSigMap
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = [Edge] -> [Edge] -> [Edge]
rule664 [Edge]
_hdIofld [Edge]
_tlIofld
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = PMP -> PMP -> PMP
rule665 PMP
_hdIpmp PMP
_tlIpmp
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = PMP_R -> PMP_R -> PMP_R
rule666 PMP_R
_hdIpmpr PMP_R
_tlIpmpr
         _lhsOps :: [PLabel]
         _lhsOps :: [PLabel]
_lhsOps = PLabel -> [PLabel] -> [PLabel]
rule667 PLabel
_hdIps [PLabel]
_tlIps
         _lhsOrefHoNts :: Set NontermIdent
         _lhsOrefHoNts :: Set NontermIdent
_lhsOrefHoNts = Set NontermIdent -> Set NontermIdent -> Set NontermIdent
rule668 Set NontermIdent
_hdIrefHoNts Set NontermIdent
_tlIrefHoNts
         _lhsOrefNts :: Set NontermIdent
         _lhsOrefNts :: Set NontermIdent
_lhsOrefNts = Set NontermIdent -> Set NontermIdent -> Set NontermIdent
rule669 Set NontermIdent
_hdIrefNts Set NontermIdent
_tlIrefNts
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = Map MyOccurrence NontermIdent
-> Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule670 Map MyOccurrence NontermIdent
_hdIruleMap Map MyOccurrence NontermIdent
_tlIruleMap
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = SF_P -> SF_P -> SF_P
rule671 SF_P
_hdIsfp SF_P
_tlIsfp
         _self :: Productions
_self = Production -> Productions -> Productions
rule672 Production
_hdIself Productions
_tlIself
         _lhsOself :: Productions
         _lhsOself :: Productions
_lhsOself = forall a. a -> a
rule673 Productions
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule674 Int
_tlIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule675 Int
_tlIolab
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule676 Int
_tlIrulenumber
         _hdOain :: MyType -> MyAttributes
_hdOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule677 MyType -> MyAttributes
_lhsIain
         _hdOan :: MyType -> MyAttributes
_hdOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule678 MyType -> MyAttributes
_lhsIan
         _hdOaroundMap :: Map NontermIdent (Map NontermIdent [Expression])
_hdOaroundMap = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule679 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap
         _hdOasn :: MyType -> MyAttributes
_hdOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule680 MyType -> MyAttributes
_lhsIasn
         _hdOaugM :: Map NontermIdent (Set Dependency)
_hdOaugM = Map NontermIdent (Set Dependency)
-> Map NontermIdent (Set Dependency)
rule681 Map NontermIdent (Set Dependency)
_lhsIaugM
         _hdOdty :: MyType
_hdOdty = MyType -> MyType
rule682 MyType
_lhsIdty
         _hdOflab :: Int
_hdOflab = Int -> Int
rule683 Int
_lhsIflab
         _hdOfty :: FTY
_hdOfty = FTY -> FTY
rule684 FTY
_lhsIfty
         _hdOftyf :: FTY
_hdOftyf = FTY -> FTY
rule685 FTY
_lhsIftyf
         _hdOhoMapf :: HOMap
_hdOhoMapf = HOMap -> HOMap
rule686 HOMap
_lhsIhoMapf
         _hdOlfpf :: SF_P
_hdOlfpf = SF_P -> SF_P
rule687 SF_P
_lhsIlfpf
         _hdOmergeMap :: Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_hdOmergeMap = Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
rule688 Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap
         _hdOmysegments :: [MySegment]
_hdOmysegments = [MySegment] -> [MySegment]
rule689 [MySegment]
_lhsImysegments
         _hdOnmp :: NMP
_hdOnmp = NMP -> NMP
rule690 NMP
_lhsInmp
         _hdOnmprf :: NMP_R
_hdOnmprf = NMP_R -> NMP_R
rule691 NMP_R
_lhsInmprf
         _hdOolab :: Int
_hdOolab = Int -> Int
rule692 Int
_lhsIolab
         _hdOoptions :: Options
_hdOoptions = Options -> Options
rule693 Options
_lhsIoptions
         _hdOpmpf :: PMP
_hdOpmpf = PMP -> PMP
rule694 PMP
_lhsIpmpf
         _hdOpmprf :: PMP_R
_hdOpmprf = PMP_R -> PMP_R
rule695 PMP_R
_lhsIpmprf
         _hdOres_ads :: [Edge]
_hdOres_ads = [Edge] -> [Edge]
rule696 [Edge]
_lhsIres_ads
         _hdOrulenumber :: Int
_hdOrulenumber = Int -> Int
rule697 Int
_lhsIrulenumber
         _hdOtdp :: TDPRes
_hdOtdp = TDPRes -> TDPRes
rule698 TDPRes
_lhsItdp
         _hdOvisMapf :: IntMap Int
_hdOvisMapf = IntMap Int -> IntMap Int
rule699 IntMap Int
_lhsIvisMapf
         _hdOvisitnum :: Int
_hdOvisitnum = Int -> Int
rule700 Int
_lhsIvisitnum
         _tlOain :: MyType -> MyAttributes
_tlOain = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule701 MyType -> MyAttributes
_lhsIain
         _tlOan :: MyType -> MyAttributes
_tlOan = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule702 MyType -> MyAttributes
_lhsIan
         _tlOaroundMap :: Map NontermIdent (Map NontermIdent [Expression])
_tlOaroundMap = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule703 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap
         _tlOasn :: MyType -> MyAttributes
_tlOasn = (MyType -> MyAttributes) -> MyType -> MyAttributes
rule704 MyType -> MyAttributes
_lhsIasn
         _tlOaugM :: Map NontermIdent (Set Dependency)
_tlOaugM = Map NontermIdent (Set Dependency)
-> Map NontermIdent (Set Dependency)
rule705 Map NontermIdent (Set Dependency)
_lhsIaugM
         _tlOdty :: MyType
_tlOdty = MyType -> MyType
rule706 MyType
_lhsIdty
         _tlOflab :: Int
_tlOflab = Int -> Int
rule707 Int
_hdIflab
         _tlOfty :: FTY
_tlOfty = FTY -> FTY
rule708 FTY
_hdIfty
         _tlOftyf :: FTY
_tlOftyf = FTY -> FTY
rule709 FTY
_lhsIftyf
         _tlOhoMapf :: HOMap
_tlOhoMapf = HOMap -> HOMap
rule710 HOMap
_lhsIhoMapf
         _tlOlfpf :: SF_P
_tlOlfpf = SF_P -> SF_P
rule711 SF_P
_lhsIlfpf
         _tlOmergeMap :: Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_tlOmergeMap = Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
-> Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
rule712 Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap
         _tlOmysegments :: [MySegment]
_tlOmysegments = [MySegment] -> [MySegment]
rule713 [MySegment]
_lhsImysegments
         _tlOnmp :: NMP
_tlOnmp = NMP -> NMP
rule714 NMP
_lhsInmp
         _tlOnmprf :: NMP_R
_tlOnmprf = NMP_R -> NMP_R
rule715 NMP_R
_lhsInmprf
         _tlOolab :: Int
_tlOolab = Int -> Int
rule716 Int
_hdIolab
         _tlOoptions :: Options
_tlOoptions = Options -> Options
rule717 Options
_lhsIoptions
         _tlOpmpf :: PMP
_tlOpmpf = PMP -> PMP
rule718 PMP
_lhsIpmpf
         _tlOpmprf :: PMP_R
_tlOpmprf = PMP_R -> PMP_R
rule719 PMP_R
_lhsIpmprf
         _tlOres_ads :: [Edge]
_tlOres_ads = [Edge] -> [Edge]
rule720 [Edge]
_lhsIres_ads
         _tlOrulenumber :: Int
_tlOrulenumber = Int -> Int
rule721 Int
_hdIrulenumber
         _tlOtdp :: TDPRes
_tlOtdp = TDPRes -> TDPRes
rule722 TDPRes
_lhsItdp
         _tlOvisMapf :: IntMap Int
_tlOvisMapf = IntMap Int -> IntMap Int
rule723 IntMap Int
_lhsIvisMapf
         __result_ :: T_Productions_vOut85
__result_ = [Edge]
-> A_P
-> EProductions
-> Map NontermIdent (Set Dependency)
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Set NontermIdent
-> Set NontermIdent
-> Map MyOccurrence NontermIdent
-> Int
-> Productions
-> SF_P
-> Int
-> T_Productions_vOut85
T_Productions_vOut85 [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Productions
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum
         in T_Productions_vOut85
__result_ )
     in T_Productions_v85 -> T_Productions_s86
C_Productions_s86 T_Productions_v85
v85
   {-# INLINE rule649 #-}
   {-# LINE 192 "src-ag/LOAG/Order.ag" #-}
   rule649 = \ ((_lhsIvisitnum) :: Int) ->
                          {-# LINE 192 "src-ag/LOAG/Order.ag" #-}
                          _lhsIvisitnum
                          {-# LINE 5341 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule650 #-}
   {-# LINE 193 "src-ag/LOAG/Order.ag" #-}
   rule650 = \ ((_hdIvisitnum) :: Int) ->
                          {-# LINE 193 "src-ag/LOAG/Order.ag" #-}
                          _hdIvisitnum
                          {-# LINE 5347 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule651 #-}
   rule651 = \ ((_hdIads) :: [Edge]) ((_tlIads) :: [Edge]) ->
     ((++) _hdIads _tlIads)
   {-# INLINE rule652 #-}
   rule652 = \ ((_hdIap) :: A_P) ((_tlIap) :: A_P) ->
     (Map.unionWith (++) _hdIap _tlIap)
   {-# INLINE rule653 #-}
   rule653 = \ ((_hdIeprods) :: EProductions) ((_tlIeprods) :: EProductions) ->
     ((++) _hdIeprods _tlIeprods)
   {-# INLINE rule654 #-}
   rule654 = \ ((_hdIfdps) :: Map.Map ConstructorIdent (Set Dependency)) ((_tlIfdps) :: Map.Map ConstructorIdent (Set Dependency)) ->
     (Map.union _hdIfdps _tlIfdps)
   {-# INLINE rule655 #-}
   rule655 = \ ((_hdIfieldMap) :: FMap) ((_tlIfieldMap) :: FMap) ->
     ((Map.union) _hdIfieldMap _tlIfieldMap)
   {-# INLINE rule656 #-}
   rule656 = \ ((_hdIfsInP) :: FsInP) ((_tlIfsInP) :: FsInP) ->
     ((Map.union) _hdIfsInP _tlIfsInP)
   {-# INLINE rule657 #-}
   rule657 = \ ((_hdIfty) :: FTY) ((_tlIfty) :: FTY) ->
     (Map.union _hdIfty _tlIfty)
   {-# INLINE rule658 #-}
   rule658 = \ ((_hdIgen) :: Map Int Int) ((_tlIgen) :: Map Int Int) ->
     (Map.union _hdIgen _tlIgen)
   {-# INLINE rule659 #-}
   rule659 = \ ((_hdIhoMap) :: HOMap) ((_tlIhoMap) :: HOMap) ->
     ((Map.union) _hdIhoMap _tlIhoMap)
   {-# INLINE rule660 #-}
   rule660 = \ ((_hdIinss) :: Map Int [Int]) ((_tlIinss) :: Map Int [Int]) ->
     (Map.unionWith (++) _hdIinss _tlIinss)
   {-# INLINE rule661 #-}
   rule661 = \ ((_hdIlfp) :: SF_P) ((_tlIlfp) :: SF_P) ->
     (Map.unionWith (Set.union) _hdIlfp _tlIlfp)
   {-# INLINE rule662 #-}
   rule662 = \ ((_hdIlfpr) :: SF_P) ((_tlIlfpr) :: SF_P) ->
     (Map.unionWith (Set.union) _hdIlfpr _tlIlfpr)
   {-# INLINE rule663 #-}
   rule663 = \ ((_hdIlocalSigMap) :: Map.Map ConstructorIdent (Map.Map Identifier Type)) ((_tlIlocalSigMap) :: Map.Map ConstructorIdent (Map.Map Identifier Type)) ->
     _hdIlocalSigMap `Map.union` _tlIlocalSigMap
   {-# INLINE rule664 #-}
   rule664 = \ ((_hdIofld) :: [(Int, Int)]) ((_tlIofld) :: [(Int, Int)]) ->
     ((++) _hdIofld _tlIofld)
   {-# INLINE rule665 #-}
   rule665 = \ ((_hdIpmp) :: PMP) ((_tlIpmp) :: PMP) ->
     (Map.union _hdIpmp _tlIpmp)
   {-# INLINE rule666 #-}
   rule666 = \ ((_hdIpmpr) :: PMP_R) ((_tlIpmpr) :: PMP_R) ->
     (Map.union _hdIpmpr _tlIpmpr)
   {-# INLINE rule667 #-}
   rule667 = \ ((_hdIps) :: PLabel) ((_tlIps) :: [PLabel]) ->
     _hdIps : _tlIps
   {-# INLINE rule668 #-}
   rule668 = \ ((_hdIrefHoNts) :: Set NontermIdent) ((_tlIrefHoNts) :: Set NontermIdent) ->
     _hdIrefHoNts `mappend` _tlIrefHoNts
   {-# INLINE rule669 #-}
   rule669 = \ ((_hdIrefNts) :: Set NontermIdent) ((_tlIrefNts) :: Set NontermIdent) ->
     _hdIrefNts `mappend` _tlIrefNts
   {-# INLINE rule670 #-}
   rule670 = \ ((_hdIruleMap) :: Map.Map MyOccurrence Identifier) ((_tlIruleMap) :: Map.Map MyOccurrence Identifier) ->
     (Map.union _hdIruleMap _tlIruleMap)
   {-# INLINE rule671 #-}
   rule671 = \ ((_hdIsfp) :: SF_P) ((_tlIsfp) :: SF_P) ->
     (Map.unionWith (Set.union) _hdIsfp _tlIsfp)
   {-# INLINE rule672 #-}
   rule672 = \ ((_hdIself) :: Production) ((_tlIself) :: Productions) ->
     (:) _hdIself _tlIself
   {-# INLINE rule673 #-}
   rule673 = \ _self ->
     _self
   {-# INLINE rule674 #-}
   rule674 = \ ((_tlIflab) :: Int) ->
     _tlIflab
   {-# INLINE rule675 #-}
   rule675 = \ ((_tlIolab) :: Int) ->
     _tlIolab
   {-# INLINE rule676 #-}
   rule676 = \ ((_tlIrulenumber) :: Int) ->
     _tlIrulenumber
   {-# INLINE rule677 #-}
   rule677 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule678 #-}
   rule678 = \ ((_lhsIan) :: MyType -> MyAttributes) ->
     _lhsIan
   {-# INLINE rule679 #-}
   rule679 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) ->
     _lhsIaroundMap
   {-# INLINE rule680 #-}
   rule680 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule681 #-}
   rule681 = \ ((_lhsIaugM) :: Map.Map Identifier (Set.Set Dependency)) ->
     _lhsIaugM
   {-# INLINE rule682 #-}
   rule682 = \ ((_lhsIdty) :: MyType) ->
     _lhsIdty
   {-# INLINE rule683 #-}
   rule683 = \ ((_lhsIflab) :: Int) ->
     _lhsIflab
   {-# INLINE rule684 #-}
   rule684 = \ ((_lhsIfty) :: FTY) ->
     _lhsIfty
   {-# INLINE rule685 #-}
   rule685 = \ ((_lhsIftyf) :: FTY) ->
     _lhsIftyf
   {-# INLINE rule686 #-}
   rule686 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule687 #-}
   rule687 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule688 #-}
   rule688 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))) ->
     _lhsImergeMap
   {-# INLINE rule689 #-}
   rule689 = \ ((_lhsImysegments) :: MySegments) ->
     _lhsImysegments
   {-# INLINE rule690 #-}
   rule690 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule691 #-}
   rule691 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule692 #-}
   rule692 = \ ((_lhsIolab) :: Int) ->
     _lhsIolab
   {-# INLINE rule693 #-}
   rule693 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule694 #-}
   rule694 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule695 #-}
   rule695 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule696 #-}
   rule696 = \ ((_lhsIres_ads) :: [Edge]) ->
     _lhsIres_ads
   {-# INLINE rule697 #-}
   rule697 = \ ((_lhsIrulenumber) :: Int) ->
     _lhsIrulenumber
   {-# INLINE rule698 #-}
   rule698 = \ ((_lhsItdp) :: TDPRes) ->
     _lhsItdp
   {-# INLINE rule699 #-}
   rule699 = \ ((_lhsIvisMapf) :: IMap.IntMap Int) ->
     _lhsIvisMapf
   {-# INLINE rule700 #-}
   rule700 = \ ((_lhsIvisitnum) :: Int) ->
     _lhsIvisitnum
   {-# INLINE rule701 #-}
   rule701 = \ ((_lhsIain) :: MyType -> MyAttributes) ->
     _lhsIain
   {-# INLINE rule702 #-}
   rule702 = \ ((_lhsIan) :: MyType -> MyAttributes) ->
     _lhsIan
   {-# INLINE rule703 #-}
   rule703 = \ ((_lhsIaroundMap) :: Map ConstructorIdent (Map Identifier [Expression])) ->
     _lhsIaroundMap
   {-# INLINE rule704 #-}
   rule704 = \ ((_lhsIasn) :: MyType -> MyAttributes) ->
     _lhsIasn
   {-# INLINE rule705 #-}
   rule705 = \ ((_lhsIaugM) :: Map.Map Identifier (Set.Set Dependency)) ->
     _lhsIaugM
   {-# INLINE rule706 #-}
   rule706 = \ ((_lhsIdty) :: MyType) ->
     _lhsIdty
   {-# INLINE rule707 #-}
   rule707 = \ ((_hdIflab) :: Int) ->
     _hdIflab
   {-# INLINE rule708 #-}
   rule708 = \ ((_hdIfty) :: FTY) ->
     _hdIfty
   {-# INLINE rule709 #-}
   rule709 = \ ((_lhsIftyf) :: FTY) ->
     _lhsIftyf
   {-# INLINE rule710 #-}
   rule710 = \ ((_lhsIhoMapf) :: HOMap) ->
     _lhsIhoMapf
   {-# INLINE rule711 #-}
   rule711 = \ ((_lhsIlfpf) :: SF_P) ->
     _lhsIlfpf
   {-# INLINE rule712 #-}
   rule712 = \ ((_lhsImergeMap) :: Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression))) ->
     _lhsImergeMap
   {-# INLINE rule713 #-}
   rule713 = \ ((_lhsImysegments) :: MySegments) ->
     _lhsImysegments
   {-# INLINE rule714 #-}
   rule714 = \ ((_lhsInmp) :: NMP) ->
     _lhsInmp
   {-# INLINE rule715 #-}
   rule715 = \ ((_lhsInmprf) :: NMP_R) ->
     _lhsInmprf
   {-# INLINE rule716 #-}
   rule716 = \ ((_hdIolab) :: Int) ->
     _hdIolab
   {-# INLINE rule717 #-}
   rule717 = \ ((_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# INLINE rule718 #-}
   rule718 = \ ((_lhsIpmpf) :: PMP) ->
     _lhsIpmpf
   {-# INLINE rule719 #-}
   rule719 = \ ((_lhsIpmprf) :: PMP_R) ->
     _lhsIpmprf
   {-# INLINE rule720 #-}
   rule720 = \ ((_lhsIres_ads) :: [Edge]) ->
     _lhsIres_ads
   {-# INLINE rule721 #-}
   rule721 = \ ((_hdIrulenumber) :: Int) ->
     _hdIrulenumber
   {-# INLINE rule722 #-}
   rule722 = \ ((_lhsItdp) :: TDPRes) ->
     _lhsItdp
   {-# INLINE rule723 #-}
   rule723 = \ ((_lhsIvisMapf) :: IMap.IntMap Int) ->
     _lhsIvisMapf
{-# NOINLINE sem_Productions_Nil #-}
sem_Productions_Nil ::  T_Productions 
sem_Productions_Nil :: T_Productions
sem_Productions_Nil  = Identity T_Productions_s86 -> T_Productions
T_Productions (forall (m :: * -> *) a. Monad m => a -> m a
return T_Productions_s86
st86) where
   {-# NOINLINE st86 #-}
   st86 :: T_Productions_s86
st86 = let
      v85 :: T_Productions_v85 
      v85 :: T_Productions_v85
v85 = \ (T_Productions_vIn85 MyType -> MyAttributes
_lhsIain MyType -> MyAttributes
_lhsIan Map NontermIdent (Map NontermIdent [Expression])
_lhsIaroundMap MyType -> MyAttributes
_lhsIasn Map NontermIdent (Set Dependency)
_lhsIaugM MyType
_lhsIdty Int
_lhsIflab FTY
_lhsIfty FTY
_lhsIftyf HOMap
_lhsIhoMapf SF_P
_lhsIlfpf Map
  NontermIdent
  (Map NontermIdent (NontermIdent, [NontermIdent], Expression))
_lhsImergeMap [MySegment]
_lhsImysegments NMP
_lhsInmp NMP_R
_lhsInmprf Int
_lhsIolab Options
_lhsIoptions PMP
_lhsIpmpf PMP_R
_lhsIpmprf [Edge]
_lhsIres_ads Int
_lhsIrulenumber TDPRes
_lhsItdp IntMap Int
_lhsIvisMapf Int
_lhsIvisitnum) -> ( let
         _lhsOads :: [Edge]
         _lhsOads :: [Edge]
_lhsOads = forall {a}. () -> [a]
rule724  ()
         _lhsOap :: A_P
         _lhsOap :: A_P
_lhsOap = forall {k} {a}. () -> Map k a
rule725  ()
         _lhsOeprods :: EProductions
         _lhsOeprods :: EProductions
_lhsOeprods = forall {a}. () -> [a]
rule726  ()
         _lhsOfdps :: Map.Map ConstructorIdent (Set Dependency)
         _lhsOfdps :: Map NontermIdent (Set Dependency)
_lhsOfdps = forall {k} {a}. () -> Map k a
rule727  ()
         _lhsOfieldMap :: FMap
         _lhsOfieldMap :: FMap
_lhsOfieldMap = forall {k} {a}. () -> Map k a
rule728  ()
         _lhsOfsInP :: FsInP
         _lhsOfsInP :: Map PLabel [(PLabel, FLabel)]
_lhsOfsInP = forall {k} {a}. () -> Map k a
rule729  ()
         _lhsOfty :: FTY
         _lhsOfty :: FTY
_lhsOfty = forall {k} {a}. () -> Map k a
rule730  ()
         _lhsOgen :: Map Int Int
         _lhsOgen :: Map Int Int
_lhsOgen = forall {k} {a}. () -> Map k a
rule731  ()
         _lhsOhoMap :: HOMap
         _lhsOhoMap :: HOMap
_lhsOhoMap = forall {k} {a}. () -> Map k a
rule732  ()
         _lhsOinss :: Map Int [Int]
         _lhsOinss :: Map Int [Int]
_lhsOinss = forall {k} {a}. () -> Map k a
rule733  ()
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = forall {k} {a}. () -> Map k a
rule734  ()
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = forall {k} {a}. () -> Map k a
rule735  ()
         _lhsOlocalSigMap :: Map.Map ConstructorIdent (Map.Map Identifier Type)
         _lhsOlocalSigMap :: Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap = forall {k} {a}. () -> Map k a
rule736  ()
         _lhsOofld :: [(Int, Int)]
         _lhsOofld :: [Edge]
_lhsOofld = forall {a}. () -> [a]
rule737  ()
         _lhsOpmp :: PMP
         _lhsOpmp :: PMP
_lhsOpmp = forall {k} {a}. () -> Map k a
rule738  ()
         _lhsOpmpr :: PMP_R
         _lhsOpmpr :: PMP_R
_lhsOpmpr = forall {k} {a}. () -> Map k a
rule739  ()
         _lhsOps :: [PLabel]
         _lhsOps :: [PLabel]
_lhsOps = forall {a}. () -> [a]
rule740  ()
         _lhsOrefHoNts :: Set NontermIdent
         _lhsOrefHoNts :: Set NontermIdent
_lhsOrefHoNts = () -> Set NontermIdent
rule741  ()
         _lhsOrefNts :: Set NontermIdent
         _lhsOrefNts :: Set NontermIdent
_lhsOrefNts = () -> Set NontermIdent
rule742  ()
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = forall {k} {a}. () -> Map k a
rule743  ()
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = forall {k} {a}. () -> Map k a
rule744  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule745  ()
         _lhsOself :: Productions
         _lhsOself :: Productions
_lhsOself = forall a. a -> a
rule746 forall a. [a]
_self
         _lhsOflab :: Int
         _lhsOflab :: Int
_lhsOflab = Int -> Int
rule747 Int
_lhsIflab
         _lhsOolab :: Int
         _lhsOolab :: Int
_lhsOolab = Int -> Int
rule748 Int
_lhsIolab
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule749 Int
_lhsIrulenumber
         _lhsOvisitnum :: Int
         _lhsOvisitnum :: Int
_lhsOvisitnum = Int -> Int
rule750 Int
_lhsIvisitnum
         __result_ :: T_Productions_vOut85
__result_ = [Edge]
-> A_P
-> EProductions
-> Map NontermIdent (Set Dependency)
-> FMap
-> Int
-> Map PLabel [(PLabel, FLabel)]
-> FTY
-> Map Int Int
-> HOMap
-> Map Int [Int]
-> SF_P
-> SF_P
-> Map NontermIdent (Map NontermIdent Type)
-> [Edge]
-> Int
-> PMP
-> PMP_R
-> [PLabel]
-> Set NontermIdent
-> Set NontermIdent
-> Map MyOccurrence NontermIdent
-> Int
-> Productions
-> SF_P
-> Int
-> T_Productions_vOut85
T_Productions_vOut85 [Edge]
_lhsOads A_P
_lhsOap EProductions
_lhsOeprods Map NontermIdent (Set Dependency)
_lhsOfdps FMap
_lhsOfieldMap Int
_lhsOflab Map PLabel [(PLabel, FLabel)]
_lhsOfsInP FTY
_lhsOfty Map Int Int
_lhsOgen HOMap
_lhsOhoMap Map Int [Int]
_lhsOinss SF_P
_lhsOlfp SF_P
_lhsOlfpr Map NontermIdent (Map NontermIdent Type)
_lhsOlocalSigMap [Edge]
_lhsOofld Int
_lhsOolab PMP
_lhsOpmp PMP_R
_lhsOpmpr [PLabel]
_lhsOps Set NontermIdent
_lhsOrefHoNts Set NontermIdent
_lhsOrefNts Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Productions
_lhsOself SF_P
_lhsOsfp Int
_lhsOvisitnum
         in T_Productions_vOut85
__result_ )
     in T_Productions_v85 -> T_Productions_s86
C_Productions_s86 T_Productions_v85
v85
   {-# INLINE rule724 #-}
   rule724 :: () -> [a]
rule724 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule725 #-}
   rule725 :: () -> Map k a
rule725 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule726 #-}
   rule726 :: () -> [a]
rule726 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule727 #-}
   rule727 :: () -> Map k a
rule727 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule728 #-}
   rule728 :: () -> Map k a
rule728 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule729 #-}
   rule729 :: () -> Map k a
rule729 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule730 #-}
   rule730 :: () -> Map k a
rule730 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule731 #-}
   rule731 :: () -> Map k a
rule731 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule732 #-}
   rule732 :: () -> Map k a
rule732 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule733 #-}
   rule733 :: () -> Map k a
rule733 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule734 #-}
   rule734 :: () -> Map k a
rule734 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule735 #-}
   rule735 :: () -> Map k a
rule735 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule736 #-}
   rule736 :: () -> Map k a
rule736 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule737 #-}
   rule737 :: () -> [a]
rule737 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule738 #-}
   rule738 :: () -> Map k a
rule738 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule739 #-}
   rule739 :: () -> Map k a
rule739 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule740 #-}
   rule740 :: () -> [a]
rule740 = \  (()
_ :: ()) ->
     ([])
   {-# INLINE rule741 #-}
   rule741 :: () -> Set NontermIdent
rule741 = \  (()
_ :: ()) ->
     forall a. Monoid a => a
mempty
   {-# INLINE rule742 #-}
   rule742 :: () -> Set NontermIdent
rule742 = \  (()
_ :: ()) ->
     forall a. Monoid a => a
mempty
   {-# INLINE rule743 #-}
   rule743 :: () -> Map k a
rule743 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule744 #-}
   rule744 :: () -> Map k a
rule744 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule745 #-}
   rule745 :: () -> [a]
rule745 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule746 #-}
   rule746 :: p -> p
rule746 = \ p
_self ->
     p
_self
   {-# INLINE rule747 #-}
   rule747 :: Int -> Int
rule747 = \ ((Int
_lhsIflab) :: Int) ->
     Int
_lhsIflab
   {-# INLINE rule748 #-}
   rule748 :: Int -> Int
rule748 = \ ((Int
_lhsIolab) :: Int) ->
     Int
_lhsIolab
   {-# INLINE rule749 #-}
   rule749 :: Int -> Int
rule749 = \ ((Int
_lhsIrulenumber) :: Int) ->
     Int
_lhsIrulenumber
   {-# INLINE rule750 #-}
   rule750 :: Int -> Int
rule750 = \ ((Int
_lhsIvisitnum) :: Int) ->
     Int
_lhsIvisitnum

-- Rule --------------------------------------------------------
-- wrapper
data Inh_Rule  = Inh_Rule { Inh_Rule -> MyType
dty_Inh_Rule :: (MyType), Inh_Rule -> SF_P
lfpf_Inh_Rule :: (SF_P), Inh_Rule -> PLabel
pll_Inh_Rule :: (PLabel), Inh_Rule -> Set FLabel
pts_Inh_Rule :: (Set.Set (FLabel)), Inh_Rule -> Int
rulenumber_Inh_Rule :: (Int) }
data Syn_Rule  = Syn_Rule { Syn_Rule -> ERule
erules_Syn_Rule :: (ERule), Syn_Rule -> SF_P
lfp_Syn_Rule :: (SF_P), Syn_Rule -> SF_P
lfpr_Syn_Rule :: (SF_P), Syn_Rule -> Map MyOccurrence NontermIdent
ruleMap_Syn_Rule :: (Map.Map MyOccurrence Identifier), Syn_Rule -> Int
rulenumber_Syn_Rule :: (Int), Syn_Rule -> Rule
self_Syn_Rule :: (Rule), Syn_Rule -> SF_P
sfp_Syn_Rule :: (SF_P), Syn_Rule -> Set MyOccurrence
used_Syn_Rule :: (Set.Set MyOccurrence), Syn_Rule -> Set MyOccurrence
usedLocals_Syn_Rule :: (Set.Set MyOccurrence) }
{-# INLINABLE wrap_Rule #-}
wrap_Rule :: T_Rule  -> Inh_Rule  -> (Syn_Rule )
wrap_Rule :: T_Rule -> Inh_Rule -> Syn_Rule
wrap_Rule (T_Rule Identity T_Rule_s89
act) (Inh_Rule MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Rule_s89
sem <- Identity T_Rule_s89
act
        let arg88 :: T_Rule_vIn88
arg88 = MyType -> SF_P -> PLabel -> Set FLabel -> Int -> T_Rule_vIn88
T_Rule_vIn88 MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber
        (T_Rule_vOut88 ERule
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rule
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOused Set MyOccurrence
_lhsOusedLocals) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Rule_s89 -> T_Rule_v88
inv_Rule_s89 T_Rule_s89
sem T_Rule_vIn88
arg88)
        forall (m :: * -> *) a. Monad m => a -> m a
return (ERule
-> SF_P
-> SF_P
-> Map MyOccurrence NontermIdent
-> Int
-> Rule
-> SF_P
-> Set MyOccurrence
-> Set MyOccurrence
-> Syn_Rule
Syn_Rule ERule
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rule
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOused Set MyOccurrence
_lhsOusedLocals)
   )

-- cata
{-# INLINE sem_Rule #-}
sem_Rule :: Rule  -> T_Rule 
sem_Rule :: Rule -> T_Rule
sem_Rule ( Rule Maybe NontermIdent
mbName_ Pattern
pattern_ Expression
rhs_ Bool
owrt_ FLabel
origin_ Bool
explicit_ Bool
pure_ Bool
identity_ Maybe Error
mbError_ Bool
eager_ ) = Maybe NontermIdent
-> T_Pattern
-> T_Expression
-> Bool
-> FLabel
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Bool
-> T_Rule
sem_Rule_Rule Maybe NontermIdent
mbName_ ( Pattern -> T_Pattern
sem_Pattern Pattern
pattern_ ) ( Expression -> T_Expression
sem_Expression Expression
rhs_ ) Bool
owrt_ FLabel
origin_ Bool
explicit_ Bool
pure_ Bool
identity_ Maybe Error
mbError_ Bool
eager_

-- semantic domain
newtype T_Rule  = T_Rule {
                         T_Rule -> Identity T_Rule_s89
attach_T_Rule :: Identity (T_Rule_s89 )
                         }
newtype T_Rule_s89  = C_Rule_s89 {
                                 T_Rule_s89 -> T_Rule_v88
inv_Rule_s89 :: (T_Rule_v88 )
                                 }
data T_Rule_s90  = C_Rule_s90
type T_Rule_v88  = (T_Rule_vIn88 ) -> (T_Rule_vOut88 )
data T_Rule_vIn88  = T_Rule_vIn88 (MyType) (SF_P) (PLabel) (Set.Set (FLabel)) (Int)
data T_Rule_vOut88  = T_Rule_vOut88 (ERule) (SF_P) (SF_P) (Map.Map MyOccurrence Identifier) (Int) (Rule) (SF_P) (Set.Set MyOccurrence) (Set.Set MyOccurrence)
{-# 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 :: Maybe NontermIdent
-> T_Pattern
-> T_Expression
-> Bool
-> FLabel
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Bool
-> T_Rule
sem_Rule_Rule Maybe NontermIdent
arg_mbName_ T_Pattern
arg_pattern_ T_Expression
arg_rhs_ Bool
arg_owrt_ FLabel
arg_origin_ Bool
arg_explicit_ Bool
arg_pure_ Bool
arg_identity_ Maybe Error
arg_mbError_ Bool
arg_eager_ = Identity T_Rule_s89 -> T_Rule
T_Rule (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rule_s89
st89) where
   {-# NOINLINE st89 #-}
   st89 :: T_Rule_s89
st89 = let
      v88 :: T_Rule_v88 
      v88 :: T_Rule_v88
v88 = \ (T_Rule_vIn88 MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber) -> ( let
         _patternX77 :: T_Pattern_s77
_patternX77 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s77
attach_T_Pattern (T_Pattern
arg_pattern_))
         _rhsX41 :: T_Expression_s41
_rhsX41 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Expression -> Identity T_Expression_s41
attach_T_Expression (T_Expression
arg_rhs_))
         (T_Pattern_vOut76 [(FLabel, (FLabel, Direction), Bool)]
_patternIafs Pattern
_patternIcopy Pattern
_patternIself) = T_Pattern_s77 -> T_Pattern_v76
inv_Pattern_s77 T_Pattern_s77
_patternX77 (T_Pattern_vIn76
T_Pattern_vIn76 )
         (T_Expression_vOut40 Expression
_rhsIcopy Expression
_rhsIself Set MyOccurrence
_rhsIused) = T_Expression_s41 -> T_Expression_v40
inv_Expression_s41 T_Expression_s41
_rhsX41 (PLabel -> Set FLabel -> T_Expression_vIn40
T_Expression_vIn40 PLabel
_rhsOpll Set FLabel
_rhsOpts)
         _lhsOerules :: ERule
         _lhsOerules :: ERule
_lhsOerules = Pattern
-> Expression
-> NontermIdent
-> Bool
-> Maybe Error
-> FLabel
-> Bool
-> Bool
-> ERule
rule751 Pattern
_patternIcopy Expression
_rhsIcopy NontermIdent
_rulename Bool
arg_explicit_ Maybe Error
arg_mbError_ FLabel
arg_origin_ Bool
arg_owrt_ Bool
arg_pure_
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule752 Int
_lhsIrulenumber
         _rulename :: NontermIdent
_rulename = Int -> Maybe NontermIdent -> NontermIdent
rule753 Int
_lhsIrulenumber Maybe NontermIdent
arg_mbName_
         _usedLocals :: Set MyOccurrence
_usedLocals = Set MyOccurrence -> Set MyOccurrence
rule754 Set MyOccurrence
_rhsIused
         _usesLocals :: Bool
_usesLocals = forall a. Set a -> Bool
rule755 Set MyOccurrence
_usedLocals
         _lhsOsfp :: SF_P
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOlfp :: SF_P
         _lhsOlfpr :: SF_P
         (SF_P
_lhsOsfp,Map MyOccurrence NontermIdent
_lhsOruleMap,SF_P
_lhsOlfp,SF_P
_lhsOlfpr) = forall {a}.
SF_P
-> PLabel
-> [(FLabel, (FLabel, Direction), Bool)]
-> Set MyOccurrence
-> a
-> Set MyOccurrence
-> Bool
-> (SF_P, Map MyOccurrence a, SF_P, SF_P)
rule756 SF_P
_lhsIlfpf PLabel
_lhsIpll [(FLabel, (FLabel, Direction), Bool)]
_patternIafs Set MyOccurrence
_rhsIused NontermIdent
_rulename Set MyOccurrence
_usedLocals Bool
_usesLocals
         _lhsOused :: Set.Set MyOccurrence
         _lhsOused :: Set MyOccurrence
_lhsOused = Set MyOccurrence -> Set MyOccurrence
rule757 Set MyOccurrence
_rhsIused
         _lhsOusedLocals :: Set.Set MyOccurrence
         _lhsOusedLocals :: Set MyOccurrence
_lhsOusedLocals = forall a. a -> a
rule758 Set MyOccurrence
_usedLocals
         _self :: Rule
_self = Pattern
-> Expression
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Maybe NontermIdent
-> FLabel
-> Bool
-> Bool
-> Rule
rule759 Pattern
_patternIself Expression
_rhsIself Bool
arg_eager_ Bool
arg_explicit_ Bool
arg_identity_ Maybe Error
arg_mbError_ Maybe NontermIdent
arg_mbName_ FLabel
arg_origin_ Bool
arg_owrt_ Bool
arg_pure_
         _lhsOself :: Rule
         _lhsOself :: Rule
_lhsOself = forall a. a -> a
rule760 Rule
_self
         _rhsOpll :: PLabel
_rhsOpll = PLabel -> PLabel
rule761 PLabel
_lhsIpll
         _rhsOpts :: Set FLabel
_rhsOpts = Set FLabel -> Set FLabel
rule762 Set FLabel
_lhsIpts
         __result_ :: T_Rule_vOut88
__result_ = ERule
-> SF_P
-> SF_P
-> Map MyOccurrence NontermIdent
-> Int
-> Rule
-> SF_P
-> Set MyOccurrence
-> Set MyOccurrence
-> T_Rule_vOut88
T_Rule_vOut88 ERule
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rule
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOused Set MyOccurrence
_lhsOusedLocals
         in T_Rule_vOut88
__result_ )
     in T_Rule_v88 -> T_Rule_s89
C_Rule_s89 T_Rule_v88
v88
   {-# INLINE rule751 #-}
   {-# LINE 65 "src-ag/ExecutionPlanCommon.ag" #-}
   rule751 = \ ((_patternIcopy) :: Pattern) ((_rhsIcopy) :: Expression) _rulename explicit_ mbError_ origin_ owrt_ pure_ ->
                        {-# LINE 65 "src-ag/ExecutionPlanCommon.ag" #-}
                        ERule _rulename
                              _patternIcopy
                              _rhsIcopy
                              owrt_
                              origin_
                              explicit_
                              pure_
                              mbError_
                        {-# LINE 5789 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule752 #-}
   {-# LINE 12 "src-ag/ExecutionPlanPre.ag" #-}
   rule752 = \ ((_lhsIrulenumber) :: Int) ->
                             {-# LINE 12 "src-ag/ExecutionPlanPre.ag" #-}
                             _lhsIrulenumber + 1
                             {-# LINE 5795 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule753 #-}
   {-# LINE 13 "src-ag/ExecutionPlanPre.ag" #-}
   rule753 = \ ((_lhsIrulenumber) :: Int) mbName_ ->
                             {-# LINE 13 "src-ag/ExecutionPlanPre.ag" #-}
                             maybe (identifier $ "rule" ++ show _lhsIrulenumber) id mbName_
                             {-# LINE 5801 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule754 #-}
   {-# LINE 230 "src-ag/LOAG/Prepare.ag" #-}
   rule754 = \ ((_rhsIused) :: Set.Set MyOccurrence) ->
                       {-# LINE 230 "src-ag/LOAG/Prepare.ag" #-}
                       Set.filter (\(MyOccurrence (_,f) _) -> f == "loc") _rhsIused
                       {-# LINE 5807 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule755 #-}
   {-# LINE 231 "src-ag/LOAG/Prepare.ag" #-}
   rule755 = \ _usedLocals ->
                       {-# LINE 231 "src-ag/LOAG/Prepare.ag" #-}
                       not $ Set.null _usedLocals
                       {-# LINE 5813 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule756 #-}
   {-# LINE 233 "src-ag/LOAG/Prepare.ag" #-}
   rule756 = \ ((_lhsIlfpf) :: SF_P) ((_lhsIpll) :: PLabel) ((_patternIafs) :: [(FLabel, ALabel, Bool)]) ((_rhsIused) :: Set.Set MyOccurrence) _rulename _usedLocals _usesLocals ->
          {-# LINE 233 "src-ag/LOAG/Prepare.ag" #-}
          foldr (\(f, a, b) (m',rm', l', lr') ->
            let att = (_lhsIpll, f) >.< a
                rm  = Map.insert att _rulename rm'
                l   = if _usesLocals     && not b
                        then Map.insert att _usedLocals     l'
                        else l'
                lr  = if _usesLocals     && not b
                       then Set.fold (\k m -> Map.insertWith (Set.union) k
                                   (Set.singleton att) m) lr' _usedLocals
                       else lr'
                sfpins = Map.insert att (_rhsIused `Set.union` fromHO) m'
                fromHO = maybe Set.empty id (Map.lookup hOcc _lhsIlfpf)
                  where hOcc = (_lhsIpll, "inst") >.< (f, AnyDir)
              in if b
                  then (m',rm, Map.insert att _rhsIused l,
                          Set.fold (\k m -> Map.insertWith (Set.union) k
                                  (Set.singleton att) m) lr _rhsIused)
                  else (sfpins,rm,l,lr))
                          (Map.empty,Map.empty,Map.empty,Map.empty) _patternIafs
          {-# LINE 5837 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule757 #-}
   rule757 = \ ((_rhsIused) :: Set.Set MyOccurrence) ->
     _rhsIused
   {-# INLINE rule758 #-}
   rule758 = \ _usedLocals ->
     _usedLocals
   {-# INLINE rule759 #-}
   rule759 = \ ((_patternIself) :: Pattern) ((_rhsIself) :: Expression) eager_ explicit_ identity_ mbError_ mbName_ origin_ owrt_ pure_ ->
     Rule mbName_ _patternIself _rhsIself owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_
   {-# INLINE rule760 #-}
   rule760 = \ _self ->
     _self
   {-# INLINE rule761 #-}
   rule761 = \ ((_lhsIpll) :: PLabel) ->
     _lhsIpll
   {-# INLINE rule762 #-}
   rule762 = \ ((_lhsIpts) :: Set.Set (FLabel)) ->
     _lhsIpts

-- Rules -------------------------------------------------------
-- wrapper
data Inh_Rules  = Inh_Rules { Inh_Rules -> MyType
dty_Inh_Rules :: (MyType), Inh_Rules -> SF_P
lfpf_Inh_Rules :: (SF_P), Inh_Rules -> PLabel
pll_Inh_Rules :: (PLabel), Inh_Rules -> Set FLabel
pts_Inh_Rules :: (Set.Set (FLabel)), Inh_Rules -> Int
rulenumber_Inh_Rules :: (Int) }
data Syn_Rules  = Syn_Rules { Syn_Rules -> ERules
erules_Syn_Rules :: (ERules), Syn_Rules -> SF_P
lfp_Syn_Rules :: (SF_P), Syn_Rules -> SF_P
lfpr_Syn_Rules :: (SF_P), Syn_Rules -> Map MyOccurrence NontermIdent
ruleMap_Syn_Rules :: (Map.Map MyOccurrence Identifier), Syn_Rules -> Int
rulenumber_Syn_Rules :: (Int), Syn_Rules -> Rules
self_Syn_Rules :: (Rules), Syn_Rules -> SF_P
sfp_Syn_Rules :: (SF_P), Syn_Rules -> Set MyOccurrence
usedLocals_Syn_Rules :: (Set.Set MyOccurrence) }
{-# INLINABLE wrap_Rules #-}
wrap_Rules :: T_Rules  -> Inh_Rules  -> (Syn_Rules )
wrap_Rules :: T_Rules -> Inh_Rules -> Syn_Rules
wrap_Rules (T_Rules Identity T_Rules_s92
act) (Inh_Rules MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Rules_s92
sem <- Identity T_Rules_s92
act
        let arg91 :: T_Rules_vIn91
arg91 = MyType -> SF_P -> PLabel -> Set FLabel -> Int -> T_Rules_vIn91
T_Rules_vIn91 MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber
        (T_Rules_vOut91 ERules
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rules
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOusedLocals) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Rules_s92 -> T_Rules_v91
inv_Rules_s92 T_Rules_s92
sem T_Rules_vIn91
arg91)
        forall (m :: * -> *) a. Monad m => a -> m a
return (ERules
-> SF_P
-> SF_P
-> Map MyOccurrence NontermIdent
-> Int
-> Rules
-> SF_P
-> Set MyOccurrence
-> Syn_Rules
Syn_Rules ERules
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rules
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOusedLocals)
   )

-- cata
{-# NOINLINE sem_Rules #-}
sem_Rules :: Rules  -> T_Rules 
sem_Rules :: Rules -> T_Rules
sem_Rules Rules
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons T_Rules
sem_Rules_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map Rule -> T_Rule
sem_Rule Rules
list)

-- semantic domain
newtype T_Rules  = T_Rules {
                           T_Rules -> Identity T_Rules_s92
attach_T_Rules :: Identity (T_Rules_s92 )
                           }
newtype T_Rules_s92  = C_Rules_s92 {
                                   T_Rules_s92 -> T_Rules_v91
inv_Rules_s92 :: (T_Rules_v91 )
                                   }
data T_Rules_s93  = C_Rules_s93
type T_Rules_v91  = (T_Rules_vIn91 ) -> (T_Rules_vOut91 )
data T_Rules_vIn91  = T_Rules_vIn91 (MyType) (SF_P) (PLabel) (Set.Set (FLabel)) (Int)
data T_Rules_vOut91  = T_Rules_vOut91 (ERules) (SF_P) (SF_P) (Map.Map MyOccurrence Identifier) (Int) (Rules) (SF_P) (Set.Set MyOccurrence)
{-# NOINLINE sem_Rules_Cons #-}
sem_Rules_Cons :: T_Rule  -> T_Rules  -> T_Rules 
sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons T_Rule
arg_hd_ T_Rules
arg_tl_ = Identity T_Rules_s92 -> T_Rules
T_Rules (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rules_s92
st92) where
   {-# NOINLINE st92 #-}
   st92 :: T_Rules_s92
st92 = let
      v91 :: T_Rules_v91 
      v91 :: T_Rules_v91
v91 = \ (T_Rules_vIn91 MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber) -> ( let
         _hdX89 :: T_Rule_s89
_hdX89 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rule -> Identity T_Rule_s89
attach_T_Rule (T_Rule
arg_hd_))
         _tlX92 :: T_Rules_s92
_tlX92 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s92
attach_T_Rules (T_Rules
arg_tl_))
         (T_Rule_vOut88 ERule
_hdIerules SF_P
_hdIlfp SF_P
_hdIlfpr Map MyOccurrence NontermIdent
_hdIruleMap Int
_hdIrulenumber Rule
_hdIself SF_P
_hdIsfp Set MyOccurrence
_hdIused Set MyOccurrence
_hdIusedLocals) = T_Rule_s89 -> T_Rule_v88
inv_Rule_s89 T_Rule_s89
_hdX89 (MyType -> SF_P -> PLabel -> Set FLabel -> Int -> T_Rule_vIn88
T_Rule_vIn88 MyType
_hdOdty SF_P
_hdOlfpf PLabel
_hdOpll Set FLabel
_hdOpts Int
_hdOrulenumber)
         (T_Rules_vOut91 ERules
_tlIerules SF_P
_tlIlfp SF_P
_tlIlfpr Map MyOccurrence NontermIdent
_tlIruleMap Int
_tlIrulenumber Rules
_tlIself SF_P
_tlIsfp Set MyOccurrence
_tlIusedLocals) = T_Rules_s92 -> T_Rules_v91
inv_Rules_s92 T_Rules_s92
_tlX92 (MyType -> SF_P -> PLabel -> Set FLabel -> Int -> T_Rules_vIn91
T_Rules_vIn91 MyType
_tlOdty SF_P
_tlOlfpf PLabel
_tlOpll Set FLabel
_tlOpts Int
_tlOrulenumber)
         _lhsOerules :: ERules
         _lhsOerules :: ERules
_lhsOerules = ERule -> ERules -> ERules
rule763 ERule
_hdIerules ERules
_tlIerules
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = SF_P -> SF_P -> SF_P
rule764 SF_P
_hdIlfp SF_P
_tlIlfp
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = SF_P -> SF_P -> SF_P
rule765 SF_P
_hdIlfpr SF_P
_tlIlfpr
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = Map MyOccurrence NontermIdent
-> Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule766 Map MyOccurrence NontermIdent
_hdIruleMap Map MyOccurrence NontermIdent
_tlIruleMap
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = SF_P -> SF_P -> SF_P
rule767 SF_P
_hdIsfp SF_P
_tlIsfp
         _lhsOusedLocals :: Set.Set MyOccurrence
         _lhsOusedLocals :: Set MyOccurrence
_lhsOusedLocals = Set MyOccurrence -> Set MyOccurrence -> Set MyOccurrence
rule768 Set MyOccurrence
_hdIusedLocals Set MyOccurrence
_tlIusedLocals
         _self :: Rules
_self = Rule -> Rules -> Rules
rule769 Rule
_hdIself Rules
_tlIself
         _lhsOself :: Rules
         _lhsOself :: Rules
_lhsOself = forall a. a -> a
rule770 Rules
_self
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule771 Int
_tlIrulenumber
         _hdOdty :: MyType
_hdOdty = MyType -> MyType
rule772 MyType
_lhsIdty
         _hdOlfpf :: SF_P
_hdOlfpf = SF_P -> SF_P
rule773 SF_P
_lhsIlfpf
         _hdOpll :: PLabel
_hdOpll = PLabel -> PLabel
rule774 PLabel
_lhsIpll
         _hdOpts :: Set FLabel
_hdOpts = Set FLabel -> Set FLabel
rule775 Set FLabel
_lhsIpts
         _hdOrulenumber :: Int
_hdOrulenumber = Int -> Int
rule776 Int
_lhsIrulenumber
         _tlOdty :: MyType
_tlOdty = MyType -> MyType
rule777 MyType
_lhsIdty
         _tlOlfpf :: SF_P
_tlOlfpf = SF_P -> SF_P
rule778 SF_P
_lhsIlfpf
         _tlOpll :: PLabel
_tlOpll = PLabel -> PLabel
rule779 PLabel
_lhsIpll
         _tlOpts :: Set FLabel
_tlOpts = Set FLabel -> Set FLabel
rule780 Set FLabel
_lhsIpts
         _tlOrulenumber :: Int
_tlOrulenumber = Int -> Int
rule781 Int
_hdIrulenumber
         __result_ :: T_Rules_vOut91
__result_ = ERules
-> SF_P
-> SF_P
-> Map MyOccurrence NontermIdent
-> Int
-> Rules
-> SF_P
-> Set MyOccurrence
-> T_Rules_vOut91
T_Rules_vOut91 ERules
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rules
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOusedLocals
         in T_Rules_vOut91
__result_ )
     in T_Rules_v91 -> T_Rules_s92
C_Rules_s92 T_Rules_v91
v91
   {-# INLINE rule763 #-}
   rule763 :: ERule -> ERules -> ERules
rule763 = \ ((ERule
_hdIerules) :: ERule) ((ERules
_tlIerules) :: ERules) ->
     ERule
_hdIerules forall a. a -> [a] -> [a]
: ERules
_tlIerules
   {-# INLINE rule764 #-}
   rule764 :: SF_P -> SF_P -> SF_P
rule764 = \ ((SF_P
_hdIlfp) :: SF_P) ((SF_P
_tlIlfp) :: SF_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) SF_P
_hdIlfp SF_P
_tlIlfp)
   {-# INLINE rule765 #-}
   rule765 :: SF_P -> SF_P -> SF_P
rule765 = \ ((SF_P
_hdIlfpr) :: SF_P) ((SF_P
_tlIlfpr) :: SF_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) SF_P
_hdIlfpr SF_P
_tlIlfpr)
   {-# INLINE rule766 #-}
   rule766 :: Map MyOccurrence NontermIdent
-> Map MyOccurrence NontermIdent -> Map MyOccurrence NontermIdent
rule766 = \ ((Map MyOccurrence NontermIdent
_hdIruleMap) :: Map.Map MyOccurrence Identifier) ((Map MyOccurrence NontermIdent
_tlIruleMap) :: Map.Map MyOccurrence Identifier) ->
     (forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map MyOccurrence NontermIdent
_hdIruleMap Map MyOccurrence NontermIdent
_tlIruleMap)
   {-# INLINE rule767 #-}
   rule767 :: SF_P -> SF_P -> SF_P
rule767 = \ ((SF_P
_hdIsfp) :: SF_P) ((SF_P
_tlIsfp) :: SF_P) ->
     (forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
Map.unionWith (forall a. Ord a => Set a -> Set a -> Set a
Set.union) SF_P
_hdIsfp SF_P
_tlIsfp)
   {-# INLINE rule768 #-}
   rule768 :: Set MyOccurrence -> Set MyOccurrence -> Set MyOccurrence
rule768 = \ ((Set MyOccurrence
_hdIusedLocals) :: Set.Set MyOccurrence) ((Set MyOccurrence
_tlIusedLocals) :: Set.Set MyOccurrence) ->
     ((forall a. Ord a => Set a -> Set a -> Set a
Set.union) Set MyOccurrence
_hdIusedLocals Set MyOccurrence
_tlIusedLocals)
   {-# INLINE rule769 #-}
   rule769 :: Rule -> Rules -> Rules
rule769 = \ ((Rule
_hdIself) :: Rule) ((Rules
_tlIself) :: Rules) ->
     (:) Rule
_hdIself Rules
_tlIself
   {-# INLINE rule770 #-}
   rule770 :: p -> p
rule770 = \ p
_self ->
     p
_self
   {-# INLINE rule771 #-}
   rule771 :: Int -> Int
rule771 = \ ((Int
_tlIrulenumber) :: Int) ->
     Int
_tlIrulenumber
   {-# INLINE rule772 #-}
   rule772 :: MyType -> MyType
rule772 = \ ((MyType
_lhsIdty) :: MyType) ->
     MyType
_lhsIdty
   {-# INLINE rule773 #-}
   rule773 :: SF_P -> SF_P
rule773 = \ ((SF_P
_lhsIlfpf) :: SF_P) ->
     SF_P
_lhsIlfpf
   {-# INLINE rule774 #-}
   rule774 :: PLabel -> PLabel
rule774 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule775 #-}
   rule775 :: Set FLabel -> Set FLabel
rule775 = \ ((Set FLabel
_lhsIpts) :: Set.Set (FLabel)) ->
     Set FLabel
_lhsIpts
   {-# INLINE rule776 #-}
   rule776 :: Int -> Int
rule776 = \ ((Int
_lhsIrulenumber) :: Int) ->
     Int
_lhsIrulenumber
   {-# INLINE rule777 #-}
   rule777 :: MyType -> MyType
rule777 = \ ((MyType
_lhsIdty) :: MyType) ->
     MyType
_lhsIdty
   {-# INLINE rule778 #-}
   rule778 :: SF_P -> SF_P
rule778 = \ ((SF_P
_lhsIlfpf) :: SF_P) ->
     SF_P
_lhsIlfpf
   {-# INLINE rule779 #-}
   rule779 :: PLabel -> PLabel
rule779 = \ ((PLabel
_lhsIpll) :: PLabel) ->
     PLabel
_lhsIpll
   {-# INLINE rule780 #-}
   rule780 :: Set FLabel -> Set FLabel
rule780 = \ ((Set FLabel
_lhsIpts) :: Set.Set (FLabel)) ->
     Set FLabel
_lhsIpts
   {-# INLINE rule781 #-}
   rule781 :: Int -> Int
rule781 = \ ((Int
_hdIrulenumber) :: Int) ->
     Int
_hdIrulenumber
{-# NOINLINE sem_Rules_Nil #-}
sem_Rules_Nil ::  T_Rules 
sem_Rules_Nil :: T_Rules
sem_Rules_Nil  = Identity T_Rules_s92 -> T_Rules
T_Rules (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rules_s92
st92) where
   {-# NOINLINE st92 #-}
   st92 :: T_Rules_s92
st92 = let
      v91 :: T_Rules_v91 
      v91 :: T_Rules_v91
v91 = \ (T_Rules_vIn91 MyType
_lhsIdty SF_P
_lhsIlfpf PLabel
_lhsIpll Set FLabel
_lhsIpts Int
_lhsIrulenumber) -> ( let
         _lhsOerules :: ERules
         _lhsOerules :: ERules
_lhsOerules = forall {a}. () -> [a]
rule782  ()
         _lhsOlfp :: SF_P
         _lhsOlfp :: SF_P
_lhsOlfp = forall {k} {a}. () -> Map k a
rule783  ()
         _lhsOlfpr :: SF_P
         _lhsOlfpr :: SF_P
_lhsOlfpr = forall {k} {a}. () -> Map k a
rule784  ()
         _lhsOruleMap :: Map.Map MyOccurrence Identifier
         _lhsOruleMap :: Map MyOccurrence NontermIdent
_lhsOruleMap = forall {k} {a}. () -> Map k a
rule785  ()
         _lhsOsfp :: SF_P
         _lhsOsfp :: SF_P
_lhsOsfp = forall {k} {a}. () -> Map k a
rule786  ()
         _lhsOusedLocals :: Set.Set MyOccurrence
         _lhsOusedLocals :: Set MyOccurrence
_lhsOusedLocals = forall {a}. () -> Set a
rule787  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule788  ()
         _lhsOself :: Rules
         _lhsOself :: Rules
_lhsOself = forall a. a -> a
rule789 forall a. [a]
_self
         _lhsOrulenumber :: Int
         _lhsOrulenumber :: Int
_lhsOrulenumber = Int -> Int
rule790 Int
_lhsIrulenumber
         __result_ :: T_Rules_vOut91
__result_ = ERules
-> SF_P
-> SF_P
-> Map MyOccurrence NontermIdent
-> Int
-> Rules
-> SF_P
-> Set MyOccurrence
-> T_Rules_vOut91
T_Rules_vOut91 ERules
_lhsOerules SF_P
_lhsOlfp SF_P
_lhsOlfpr Map MyOccurrence NontermIdent
_lhsOruleMap Int
_lhsOrulenumber Rules
_lhsOself SF_P
_lhsOsfp Set MyOccurrence
_lhsOusedLocals
         in T_Rules_vOut91
__result_ )
     in T_Rules_v91 -> T_Rules_s92
C_Rules_s92 T_Rules_v91
v91
   {-# INLINE rule782 #-}
   rule782 :: () -> [a]
rule782 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule783 #-}
   rule783 :: () -> Map k a
rule783 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule784 #-}
   rule784 :: () -> Map k a
rule784 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule785 #-}
   rule785 :: () -> Map k a
rule785 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule786 #-}
   rule786 :: () -> Map k a
rule786 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule787 #-}
   rule787 :: () -> Set a
rule787 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# INLINE rule788 #-}
   rule788 :: () -> [a]
rule788 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule789 #-}
   rule789 :: p -> p
rule789 = \ p
_self ->
     p
_self
   {-# INLINE rule790 #-}
   rule790 :: Int -> Int
rule790 = \ ((Int
_lhsIrulenumber) :: Int) ->
     Int
_lhsIrulenumber

-- Sequence ----------------------------------------------------
-- wrapper
data Inh_Sequence  = Inh_Sequence {  }
data Syn_Sequence  = Syn_Sequence { Syn_Sequence -> Sequence
self_Syn_Sequence :: (Sequence) }
{-# INLINABLE wrap_Sequence #-}
wrap_Sequence :: T_Sequence  -> Inh_Sequence  -> (Syn_Sequence )
wrap_Sequence :: T_Sequence -> Inh_Sequence -> Syn_Sequence
wrap_Sequence (T_Sequence Identity T_Sequence_s95
act) (Inh_Sequence
Inh_Sequence ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_Sequence_s95
sem <- Identity T_Sequence_s95
act
        let arg94 :: T_Sequence_vIn94
arg94 = T_Sequence_vIn94
T_Sequence_vIn94 
        (T_Sequence_vOut94 Sequence
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Sequence_s95 -> T_Sequence_v94
inv_Sequence_s95 T_Sequence_s95
sem T_Sequence_vIn94
arg94)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Sequence -> Syn_Sequence
Syn_Sequence Sequence
_lhsOself)
   )

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

-- semantic domain
newtype T_Sequence  = T_Sequence {
                                 T_Sequence -> Identity T_Sequence_s95
attach_T_Sequence :: Identity (T_Sequence_s95 )
                                 }
newtype T_Sequence_s95  = C_Sequence_s95 {
                                         T_Sequence_s95 -> T_Sequence_v94
inv_Sequence_s95 :: (T_Sequence_v94 )
                                         }
data T_Sequence_s96  = C_Sequence_s96
type T_Sequence_v94  = (T_Sequence_vIn94 ) -> (T_Sequence_vOut94 )
data T_Sequence_vIn94  = T_Sequence_vIn94 
data T_Sequence_vOut94  = T_Sequence_vOut94 (Sequence)
{-# NOINLINE sem_Sequence_Cons #-}
sem_Sequence_Cons :: T_CRule  -> T_Sequence  -> T_Sequence 
sem_Sequence_Cons :: T_CRule -> T_Sequence -> T_Sequence
sem_Sequence_Cons T_CRule
arg_hd_ T_Sequence
arg_tl_ = Identity T_Sequence_s95 -> T_Sequence
T_Sequence (forall (m :: * -> *) a. Monad m => a -> m a
return T_Sequence_s95
st95) where
   {-# NOINLINE st95 #-}
   st95 :: T_Sequence_s95
st95 = let
      v94 :: T_Sequence_v94 
      v94 :: T_Sequence_v94
v94 = \ (T_Sequence_vIn94
T_Sequence_vIn94 ) -> ( let
         _hdX20 :: T_CRule_s20
_hdX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_CRule -> Identity T_CRule_s20
attach_T_CRule (T_CRule
arg_hd_))
         _tlX95 :: T_Sequence_s95
_tlX95 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Sequence -> Identity T_Sequence_s95
attach_T_Sequence (T_Sequence
arg_tl_))
         (T_CRule_vOut19 CRule
_hdIself) = T_CRule_s20 -> T_CRule_v19
inv_CRule_s20 T_CRule_s20
_hdX20 (T_CRule_vIn19
T_CRule_vIn19 )
         (T_Sequence_vOut94 Sequence
_tlIself) = T_Sequence_s95 -> T_Sequence_v94
inv_Sequence_s95 T_Sequence_s95
_tlX95 (T_Sequence_vIn94
T_Sequence_vIn94 )
         _self :: Sequence
_self = CRule -> Sequence -> Sequence
rule791 CRule
_hdIself Sequence
_tlIself
         _lhsOself :: Sequence
         _lhsOself :: Sequence
_lhsOself = forall a. a -> a
rule792 Sequence
_self
         __result_ :: T_Sequence_vOut94
__result_ = Sequence -> T_Sequence_vOut94
T_Sequence_vOut94 Sequence
_lhsOself
         in T_Sequence_vOut94
__result_ )
     in T_Sequence_v94 -> T_Sequence_s95
C_Sequence_s95 T_Sequence_v94
v94
   {-# INLINE rule791 #-}
   rule791 :: CRule -> Sequence -> Sequence
rule791 = \ ((CRule
_hdIself) :: CRule) ((Sequence
_tlIself) :: Sequence) ->
     (:) CRule
_hdIself Sequence
_tlIself
   {-# INLINE rule792 #-}
   rule792 :: p -> p
rule792 = \ p
_self ->
     p
_self
{-# NOINLINE sem_Sequence_Nil #-}
sem_Sequence_Nil ::  T_Sequence 
sem_Sequence_Nil :: T_Sequence
sem_Sequence_Nil  = Identity T_Sequence_s95 -> T_Sequence
T_Sequence (forall (m :: * -> *) a. Monad m => a -> m a
return T_Sequence_s95
st95) where
   {-# NOINLINE st95 #-}
   st95 :: T_Sequence_s95
st95 = let
      v94 :: T_Sequence_v94 
      v94 :: T_Sequence_v94
v94 = \ (T_Sequence_vIn94
T_Sequence_vIn94 ) -> ( let
         _self :: [a]
_self = forall {a}. () -> [a]
rule793  ()
         _lhsOself :: Sequence
         _lhsOself :: Sequence
_lhsOself = forall a. a -> a
rule794 forall a. [a]
_self
         __result_ :: T_Sequence_vOut94
__result_ = Sequence -> T_Sequence_vOut94
T_Sequence_vOut94 Sequence
_lhsOself
         in T_Sequence_vOut94
__result_ )
     in T_Sequence_v94 -> T_Sequence_s95
C_Sequence_s95 T_Sequence_v94
v94
   {-# INLINE rule793 #-}
   rule793 :: () -> [a]
rule793 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule794 #-}
   rule794 :: p -> p
rule794 = \ p
_self ->
     p
_self

-- TypeSig -----------------------------------------------------
-- wrapper
data Inh_TypeSig  = Inh_TypeSig {  }
data Syn_TypeSig  = Syn_TypeSig { Syn_TypeSig -> Map NontermIdent Type
localSigMap_Syn_TypeSig :: (Map Identifier Type), Syn_TypeSig -> TypeSig
self_Syn_TypeSig :: (TypeSig) }
{-# INLINABLE wrap_TypeSig #-}
wrap_TypeSig :: T_TypeSig  -> Inh_TypeSig  -> (Syn_TypeSig )
wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> Syn_TypeSig
wrap_TypeSig (T_TypeSig Identity T_TypeSig_s98
act) (Inh_TypeSig
Inh_TypeSig ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_TypeSig_s98
sem <- Identity T_TypeSig_s98
act
        let arg97 :: T_TypeSig_vIn97
arg97 = T_TypeSig_vIn97
T_TypeSig_vIn97 
        (T_TypeSig_vOut97 Map NontermIdent Type
_lhsOlocalSigMap TypeSig
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_TypeSig_s98 -> T_TypeSig_v97
inv_TypeSig_s98 T_TypeSig_s98
sem T_TypeSig_vIn97
arg97)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Map NontermIdent Type -> TypeSig -> Syn_TypeSig
Syn_TypeSig Map NontermIdent Type
_lhsOlocalSigMap TypeSig
_lhsOself)
   )

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

-- semantic domain
newtype T_TypeSig  = T_TypeSig {
                               T_TypeSig -> Identity T_TypeSig_s98
attach_T_TypeSig :: Identity (T_TypeSig_s98 )
                               }
newtype T_TypeSig_s98  = C_TypeSig_s98 {
                                       T_TypeSig_s98 -> T_TypeSig_v97
inv_TypeSig_s98 :: (T_TypeSig_v97 )
                                       }
data T_TypeSig_s99  = C_TypeSig_s99
type T_TypeSig_v97  = (T_TypeSig_vIn97 ) -> (T_TypeSig_vOut97 )
data T_TypeSig_vIn97  = T_TypeSig_vIn97 
data T_TypeSig_vOut97  = T_TypeSig_vOut97 (Map Identifier Type) (TypeSig)
{-# NOINLINE sem_TypeSig_TypeSig #-}
sem_TypeSig_TypeSig :: (Identifier) -> (Type) -> T_TypeSig 
sem_TypeSig_TypeSig :: NontermIdent -> Type -> T_TypeSig
sem_TypeSig_TypeSig NontermIdent
arg_name_ Type
arg_tp_ = Identity T_TypeSig_s98 -> T_TypeSig
T_TypeSig (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSig_s98
st98) where
   {-# NOINLINE st98 #-}
   st98 :: T_TypeSig_s98
st98 = let
      v97 :: T_TypeSig_v97 
      v97 :: T_TypeSig_v97
v97 = \ (T_TypeSig_vIn97
T_TypeSig_vIn97 ) -> ( let
         _lhsOlocalSigMap :: Map Identifier Type
         _lhsOlocalSigMap :: Map NontermIdent Type
_lhsOlocalSigMap = forall k a. k -> a -> Map k a
rule795 NontermIdent
arg_name_ Type
arg_tp_
         _self :: TypeSig
_self = NontermIdent -> Type -> TypeSig
rule796 NontermIdent
arg_name_ Type
arg_tp_
         _lhsOself :: TypeSig
         _lhsOself :: TypeSig
_lhsOself = forall a. a -> a
rule797 TypeSig
_self
         __result_ :: T_TypeSig_vOut97
__result_ = Map NontermIdent Type -> TypeSig -> T_TypeSig_vOut97
T_TypeSig_vOut97 Map NontermIdent Type
_lhsOlocalSigMap TypeSig
_lhsOself
         in T_TypeSig_vOut97
__result_ )
     in T_TypeSig_v97 -> T_TypeSig_s98
C_TypeSig_s98 T_TypeSig_v97
v97
   {-# INLINE rule795 #-}
   {-# LINE 161 "src-ag/ExecutionPlanCommon.ag" #-}
   rule795 = \ name_ tp_ ->
                                                   {-# LINE 161 "src-ag/ExecutionPlanCommon.ag" #-}
                                                   Map.singleton name_ tp_
                                                   {-# LINE 6163 "src-generated/LOAG/Order.hs" #-}
   {-# INLINE rule796 #-}
   rule796 = \ name_ tp_ ->
     TypeSig name_ tp_
   {-# INLINE rule797 #-}
   rule797 = \ _self ->
     _self

-- TypeSigs ----------------------------------------------------
-- wrapper
data Inh_TypeSigs  = Inh_TypeSigs {  }
data Syn_TypeSigs  = Syn_TypeSigs { Syn_TypeSigs -> Map NontermIdent Type
localSigMap_Syn_TypeSigs :: (Map Identifier Type), Syn_TypeSigs -> TypeSigs
self_Syn_TypeSigs :: (TypeSigs) }
{-# INLINABLE wrap_TypeSigs #-}
wrap_TypeSigs :: T_TypeSigs  -> Inh_TypeSigs  -> (Syn_TypeSigs )
wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> Syn_TypeSigs
wrap_TypeSigs (T_TypeSigs Identity T_TypeSigs_s101
act) (Inh_TypeSigs
Inh_TypeSigs ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do T_TypeSigs_s101
sem <- Identity T_TypeSigs_s101
act
        let arg100 :: T_TypeSigs_vIn100
arg100 = T_TypeSigs_vIn100
T_TypeSigs_vIn100 
        (T_TypeSigs_vOut100 Map NontermIdent Type
_lhsOlocalSigMap TypeSigs
_lhsOself) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_TypeSigs_s101 -> T_TypeSigs_v100
inv_TypeSigs_s101 T_TypeSigs_s101
sem T_TypeSigs_vIn100
arg100)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Map NontermIdent Type -> TypeSigs -> Syn_TypeSigs
Syn_TypeSigs Map NontermIdent Type
_lhsOlocalSigMap TypeSigs
_lhsOself)
   )

-- cata
{-# NOINLINE sem_TypeSigs #-}
sem_TypeSigs :: TypeSigs  -> T_TypeSigs 
sem_TypeSigs :: TypeSigs -> T_TypeSigs
sem_TypeSigs TypeSigs
list = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Prelude.foldr T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons T_TypeSigs
sem_TypeSigs_Nil (forall a b. (a -> b) -> [a] -> [b]
Prelude.map TypeSig -> T_TypeSig
sem_TypeSig TypeSigs
list)

-- semantic domain
newtype T_TypeSigs  = T_TypeSigs {
                                 T_TypeSigs -> Identity T_TypeSigs_s101
attach_T_TypeSigs :: Identity (T_TypeSigs_s101 )
                                 }
newtype T_TypeSigs_s101  = C_TypeSigs_s101 {
                                           T_TypeSigs_s101 -> T_TypeSigs_v100
inv_TypeSigs_s101 :: (T_TypeSigs_v100 )
                                           }
data T_TypeSigs_s102  = C_TypeSigs_s102
type T_TypeSigs_v100  = (T_TypeSigs_vIn100 ) -> (T_TypeSigs_vOut100 )
data T_TypeSigs_vIn100  = T_TypeSigs_vIn100 
data T_TypeSigs_vOut100  = T_TypeSigs_vOut100 (Map Identifier Type) (TypeSigs)
{-# NOINLINE sem_TypeSigs_Cons #-}
sem_TypeSigs_Cons :: T_TypeSig  -> T_TypeSigs  -> T_TypeSigs 
sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons T_TypeSig
arg_hd_ T_TypeSigs
arg_tl_ = Identity T_TypeSigs_s101 -> T_TypeSigs
T_TypeSigs (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSigs_s101
st101) where
   {-# NOINLINE st101 #-}
   st101 :: T_TypeSigs_s101
st101 = let
      v100 :: T_TypeSigs_v100 
      v100 :: T_TypeSigs_v100
v100 = \ (T_TypeSigs_vIn100
T_TypeSigs_vIn100 ) -> ( let
         _hdX98 :: T_TypeSig_s98
_hdX98 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSig -> Identity T_TypeSig_s98
attach_T_TypeSig (T_TypeSig
arg_hd_))
         _tlX101 :: T_TypeSigs_s101
_tlX101 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s101
attach_T_TypeSigs (T_TypeSigs
arg_tl_))
         (T_TypeSig_vOut97 Map NontermIdent Type
_hdIlocalSigMap TypeSig
_hdIself) = T_TypeSig_s98 -> T_TypeSig_v97
inv_TypeSig_s98 T_TypeSig_s98
_hdX98 (T_TypeSig_vIn97
T_TypeSig_vIn97 )
         (T_TypeSigs_vOut100 Map NontermIdent Type
_tlIlocalSigMap TypeSigs
_tlIself) = T_TypeSigs_s101 -> T_TypeSigs_v100
inv_TypeSigs_s101 T_TypeSigs_s101
_tlX101 (T_TypeSigs_vIn100
T_TypeSigs_vIn100 )
         _lhsOlocalSigMap :: Map Identifier Type
         _lhsOlocalSigMap :: Map NontermIdent Type
_lhsOlocalSigMap = Map NontermIdent Type
-> Map NontermIdent Type -> Map NontermIdent Type
rule798 Map NontermIdent Type
_hdIlocalSigMap Map NontermIdent Type
_tlIlocalSigMap
         _self :: TypeSigs
_self = TypeSig -> TypeSigs -> TypeSigs
rule799 TypeSig
_hdIself TypeSigs
_tlIself
         _lhsOself :: TypeSigs
         _lhsOself :: TypeSigs
_lhsOself = forall a. a -> a
rule800 TypeSigs
_self
         __result_ :: T_TypeSigs_vOut100
__result_ = Map NontermIdent Type -> TypeSigs -> T_TypeSigs_vOut100
T_TypeSigs_vOut100 Map NontermIdent Type
_lhsOlocalSigMap TypeSigs
_lhsOself
         in T_TypeSigs_vOut100
__result_ )
     in T_TypeSigs_v100 -> T_TypeSigs_s101
C_TypeSigs_s101 T_TypeSigs_v100
v100
   {-# INLINE rule798 #-}
   rule798 :: Map NontermIdent Type
-> Map NontermIdent Type -> Map NontermIdent Type
rule798 = \ ((Map NontermIdent Type
_hdIlocalSigMap) :: Map Identifier Type) ((Map NontermIdent Type
_tlIlocalSigMap) :: Map Identifier Type) ->
     Map NontermIdent Type
_hdIlocalSigMap forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent Type
_tlIlocalSigMap
   {-# INLINE rule799 #-}
   rule799 :: TypeSig -> TypeSigs -> TypeSigs
rule799 = \ ((TypeSig
_hdIself) :: TypeSig) ((TypeSigs
_tlIself) :: TypeSigs) ->
     (:) TypeSig
_hdIself TypeSigs
_tlIself
   {-# INLINE rule800 #-}
   rule800 :: p -> p
rule800 = \ p
_self ->
     p
_self
{-# NOINLINE sem_TypeSigs_Nil #-}
sem_TypeSigs_Nil ::  T_TypeSigs 
sem_TypeSigs_Nil :: T_TypeSigs
sem_TypeSigs_Nil  = Identity T_TypeSigs_s101 -> T_TypeSigs
T_TypeSigs (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSigs_s101
st101) where
   {-# NOINLINE st101 #-}
   st101 :: T_TypeSigs_s101
st101 = let
      v100 :: T_TypeSigs_v100 
      v100 :: T_TypeSigs_v100
v100 = \ (T_TypeSigs_vIn100
T_TypeSigs_vIn100 ) -> ( let
         _lhsOlocalSigMap :: Map Identifier Type
         _lhsOlocalSigMap :: Map NontermIdent Type
_lhsOlocalSigMap = forall {k} {a}. () -> Map k a
rule801  ()
         _self :: [a]
_self = forall {a}. () -> [a]
rule802  ()
         _lhsOself :: TypeSigs
         _lhsOself :: TypeSigs
_lhsOself = forall a. a -> a
rule803 forall a. [a]
_self
         __result_ :: T_TypeSigs_vOut100
__result_ = Map NontermIdent Type -> TypeSigs -> T_TypeSigs_vOut100
T_TypeSigs_vOut100 Map NontermIdent Type
_lhsOlocalSigMap TypeSigs
_lhsOself
         in T_TypeSigs_vOut100
__result_ )
     in T_TypeSigs_v100 -> T_TypeSigs_s101
C_TypeSigs_s101 T_TypeSigs_v100
v100
   {-# INLINE rule801 #-}
   rule801 :: () -> Map k a
rule801 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# INLINE rule802 #-}
   rule802 :: () -> [a]
rule802 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule803 #-}
   rule803 :: p -> p
rule803 = \ p
_self ->
     p
_self