-- UUAGC 0.9.22 (Order.ag)
module Order where
{-# LINE 9 "Order.ag" #-}

-- From uuagc
import CommonTypes
import Patterns
import ErrorMessages
import AbstractSyntax
import Code hiding (Type)
import qualified Code
import Expression
import Options
import SequentialComputation
import SequentialTypes
import CodeSyntax
import GrammarInfo
import HsToken(HsTokensRoot(HsTokensRoot))
import HsTokenScanner(lexTokens)
import SemHsTokens(sem_HsTokensRoot,wrap_HsTokensRoot, Syn_HsTokensRoot(..),Inh_HsTokensRoot(..))
-- From uulib
import qualified Data.Map as Map
import qualified Data.Set as Set
import qualified Data.Sequence as Seq
import Data.Map(Map) 
import Data.Set(Set)
import Data.Sequence(Seq, (><))
import UU.Util.Utils
import UU.Scanner.Position(Pos(..),initPos)
import Data.Foldable(toList)

-- From haskell libraries
import Control.Monad(liftM)
import qualified Data.Array as Array
import Data.Array((!),bounds,inRange)
import Data.List(elemIndex,partition,sort,mapAccumL,find,nubBy,intersperse,groupBy,transpose)
import qualified Data.Tree as Tree
import Maybe
{-# LINE 42 "../src-derived/Order.hs" #-}

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

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

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

import UU.Scanner.Position(Pos)
import HsToken
{-# LINE 55 "../src-derived/Order.hs" #-}

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

-- AbstractSyntax.ag imports
import Data.Set(Set)
import Data.Map(Map)
import Patterns    (Pattern(..),Patterns)
import Expression  (Expression(..))
import CommonTypes
{-# LINE 65 "../src-derived/Order.hs" #-}
{-# LINE 46 "Order.ag" #-}

-- Terminates with an error if the key is not in the map
findWithErr1 :: (Ord k, Show k) => String -> k -> Map k a -> a
findWithErr1 s k
  = Map.findWithDefault (error ("findWithErr1 " ++ s ++ ": key " ++ show k ++ " not in map.")) k

findWithErr2 :: (Ord k, Show k, Show a) => k -> Map k a -> a
findWithErr2 k m
  = Map.findWithDefault (error ("findWithErr2: key " ++ show k ++ " not in map: " ++ show m)) k m
{-# LINE 76 "../src-derived/Order.hs" #-}

{-# LINE 118 "Order.ag" #-}

getNtName :: Type -> NontermIdent
getNtName (NT nt _) = maybe nt id (deforestedNt nt)
getNtName _         = nullIdent
{-# LINE 83 "../src-derived/Order.hs" #-}

{-# LINE 146 "Order.ag" #-}

data AltAttr = AltAttr Identifier Identifier Bool 
               deriving (Eq, Ord, Show)
{-# LINE 89 "../src-derived/Order.hs" #-}

{-# LINE 218 "Order.ag" #-}

substSelf nt tp
  = case tp of
      NT n tps | n == _SELF -> NT nt tps
      _                     -> tp
	
haskellTupel :: [Type] -> Maybe Type
haskellTupel ts =  Just ( Haskell ( '(' : (concat (intersperse "," (map show ts))) ++ ")" ))
{-# LINE 100 "../src-derived/Order.hs" #-}

{-# LINE 610 "Order.ag" #-}

swap (a,b) = (b,a)

showPath :: Table CRule -> [Vertex] -> [String]
showPath ruleTable path
  =  let  look a | inRange (bounds ruleTable) a = [showOrigin (ruleTable ! a)]
                 | otherwise = ["Vertex " ++ show a]
          showOrigin cr  | getHasCode cr && getName (getAttr cr) /= "self" = prettyCRule cr ++ " (" ++ show (getPos (getAttr cr)) ++ ")"
                         | otherwise = prettyCRule cr
     in concatMap look path


showPathLocal :: Table CRule -> [Vertex] -> [String]
showPathLocal _ [] = []
showPathLocal ruleTable xs = showP (xs++[-1])
 where showP []         = []
       showP (v1:v2:vs) = let line  = step v1 v2
                              lines = showP vs
                          in  line:lines
       step v1 v2  = " - " ++ a1
        where r1 = ruleTable ! v1
              a1 = show (getAttr  r1)


limitTo :: Int -> [String] -> [String]
limitTo _ [] = [] 
limitTo 0 _ = ["....etcetera, etcetera...."]
limitTo n (x:xs) = x : limitTo (n-1) xs

showPathNice :: Table CRule -> [Vertex] -> [String]
showPathNice _ [] = []
showPathNice ruleTable xs = limitTo 100 (showP ((-1):xs++[-1]))
 where [maxf, maxa, maxn, maxc] = maxWidths ruleTable (take 100 xs)
       showP []         = []
       showP (v1:v2:vs) = let line  = step v1 v2
                              lines = showP vs
                          in  if null line  then lines  else line:lines
       step v1 v2  |  last &&      first    = induced
                   |  last &&     isSyn r1  = "pass up        "  ++ alignR maxf ""    ++ " " ++ alignL maxa a1 ++ " in " ++ alignR maxn n1 ++ "|" ++ c1 ++ induced
                   |  first&& not(isSyn r2) = "get from above "  ++ alignR maxf ""    ++ " " ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2
                   |  last                  = "pass down      "  ++ alignR maxf f1    ++ "." ++ a1                                                      ++ induced
                   |              isSyn r2  = "get from below "  ++ alignR maxf f2    ++ "." ++ alignL maxa a2 ++ " in " ++ alignR maxn n2 ++ "|" ++ c2
                   |  isLocal r1  = if head a1 == '_' 
                                         then ""
                                         else "calculate      "  ++ alignR maxf "loc" ++ "." ++ a1
                   |  otherwise             = "pass down      "  ++ alignR maxf f1    ++ "." ++ alignL maxa a1 ++ " to " ++ alignR maxn n2 ++ "|" ++ c2
          where
              first = v1<0
              last  = v2<0
              r1 = ruleTable ! v1
              r2 = ruleTable ! v2
              a1 = show (getAttr  r1)
              a2 = show (getAttr  r2)
              f1 = show (getField r1)
              f2 = show (getField r2)
              n1 = show (getLhsNt r1)
              n2 = show (getLhsNt r2)
              c1 = show (getCon   r1)
              c2 = show (getCon   r2)
              induced | v2== -2   =  " INDUCED dependency to "
                      | otherwise = ""


maxWidths ruleTable vs
  = map maximum (transpose (map getWidth vs))
  where getWidth v | v<0       = [0,0,0,0]
                   | otherwise = map (length . show . ($ (ruleTable!v))) [getField, getAttr, getLhsNt, getCon]

alignL n xs | k<n       = xs ++ replicate (n-k) ' '
            | otherwise = xs
              where k = length xs

alignR n xs | k<n       = replicate (n-k) ' ' ++ xs
            | otherwise = xs
              where k = length xs

localCycleErr :: Table CRule -> Bool -> Route -> Error
localCycleErr ruleTable o_visit (s:path)
  =  let cr = ruleTable ! s
         attr = getAttr cr
         nt = getLhsNt cr
         con = getCon cr
     in LocalCirc nt con attr o_visit (showPathLocal ruleTable path)

instCycleErr :: Table CRule -> Bool -> Route -> Error
instCycleErr ruleTable o_visit (s:path)
  =  let cr = ruleTable ! s
         attr = getAttr cr
         nt = getLhsNt cr
         con = getCon cr
     in InstCirc nt con attr o_visit (showPathLocal ruleTable path)

directCycleErrs :: Table NTAttr -> Table CRule -> Bool -> [EdgeRoutes] -> [Error]
directCycleErrs attrTable ruleTable o_visit xs
  = let getNont v = case attrTable ! v of
                      NTASyn nt _ _ -> nt
                      NTAInh nt _ _ -> nt
        getAttr v = case attrTable ! v of
                      NTASyn _ a _  -> a
                      NTAInh _ a _  -> a
        sameNont ((v1,_),_,_) ((v2,_),_,_) =  getNont v1 == getNont v2
        procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2)
        wrapGroup gr@(((v1,_),_,_):_) = DirectCirc (getNont v1) o_visit (map procCycle gr)
    in  map wrapGroup (groupBy sameNont xs)

inducedCycleErrs :: Table NTAttr -> Table CRule -> CInterfaceMap -> [EdgeRoutes] -> [Error]
inducedCycleErrs attrTable ruleTable cim xs
  = let getNont v = case attrTable ! v of
                      NTASyn nt _ _ -> nt
                      NTAInh nt _ _ -> nt
        getAttr v = case attrTable ! v of
                      NTASyn _ a _  -> a
                      NTAInh _ a _  -> a
        sameNont ((v1,_),_,_) ((v2,_),_,_) =  getNont v1 == getNont v2
        procCycle ((v1,v2),p1,p2) = ((getAttr v1, getAttr v2), showPathNice ruleTable p1, showPathNice ruleTable p2)
        wrapGroup gr@(((v1,_),_,_):_) = InducedCirc (getNont v1) (findWithErr1 "inducedCycleErr.cinter" (getNont v1) cim) (map procCycle gr)
    in  map wrapGroup (groupBy sameNont xs)
{-# LINE 220 "../src-derived/Order.hs" #-}
-- Child -------------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allfields            : [(Identifier,Type,Bool)]
         allnts               : [Identifier]
         attrs                : [(Identifier,Identifier)]
         con                  : Identifier
         inh                  : Attributes
         nt                   : Identifier
         o_unbox              : Bool
         syn                  : Attributes
      synthesized attributes:
         attributes           : [(Identifier,Attributes,Attributes)]
         collectChildrenInhs  : Map Identifier Attributes 
         collectChildrenSyns  : Map Identifier Attributes 
         errors               : Seq Error
         field                : (Identifier,Type,Bool)
         gathAltAttrs         : [AltAttr]
         gathRules            : Seq CRule
         inhs                 : Seq (Identifier,Attributes)
         nts                  : Seq (Identifier,NontermIdent)
         singlevisits         : [CRule]
         terminals            : [Identifier]
   alternatives:
      alternative Child:
         child name           : {Identifier}
         child tp             : {Type}
         child inh            : {Attributes}
         child syn            : {Attributes}
         child higherOrder    : {Bool}
         visit 0:
            local maptolocal  : _
            local gathRules   : _
-}
-- cata
sem_Child :: Child  ->
             T_Child 
sem_Child (Child _name _tp _inh _syn _higherOrder )  =
    (sem_Child_Child _name _tp _inh _syn _higherOrder )
-- semantic domain
newtype T_Child  = T_Child (([(Identifier,Type,Bool)]) ->
                            ([Identifier]) ->
                            ([(Identifier,Identifier)]) ->
                            Identifier ->
                            Attributes ->
                            Identifier ->
                            Bool ->
                            Attributes ->
                            ( ([(Identifier,Attributes,Attributes)]),(Map Identifier Attributes ),(Map Identifier Attributes ),(Seq Error),((Identifier,Type,Bool)),([AltAttr]),(Seq CRule),(Seq (Identifier,Attributes)),(Seq (Identifier,NontermIdent)),([CRule]),([Identifier])))
data Inh_Child  = Inh_Child {allfields_Inh_Child :: !(([(Identifier,Type,Bool)])),allnts_Inh_Child :: !(([Identifier])),attrs_Inh_Child :: !(([(Identifier,Identifier)])),con_Inh_Child :: !(Identifier),inh_Inh_Child :: !(Attributes),nt_Inh_Child :: !(Identifier),o_unbox_Inh_Child :: !(Bool),syn_Inh_Child :: !(Attributes)}
data Syn_Child  = Syn_Child {attributes_Syn_Child :: !(([(Identifier,Attributes,Attributes)])),collectChildrenInhs_Syn_Child :: !((Map Identifier Attributes )),collectChildrenSyns_Syn_Child :: !((Map Identifier Attributes )),errors_Syn_Child :: !((Seq Error)),field_Syn_Child :: !(((Identifier,Type,Bool))),gathAltAttrs_Syn_Child :: !(([AltAttr])),gathRules_Syn_Child :: !((Seq CRule)),inhs_Syn_Child :: !((Seq (Identifier,Attributes))),nts_Syn_Child :: !((Seq (Identifier,NontermIdent))),singlevisits_Syn_Child :: !(([CRule])),terminals_Syn_Child :: !(([Identifier]))}
wrap_Child :: T_Child  ->
              Inh_Child  ->
              Syn_Child 
wrap_Child (T_Child sem ) (Inh_Child _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn )  =
    (let ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfield,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals) =
             (sem _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn )
     in  (Syn_Child _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfield _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals ))
sem_Child_Child :: Identifier ->
                   Type ->
                   Attributes ->
                   Attributes ->
                   Bool ->
                   T_Child 
sem_Child_Child name_ tp_ inh_ syn_ higherOrder_  =
    (T_Child (\ _lhsIallfields
                _lhsIallnts
                _lhsIattrs
                _lhsIcon
                _lhsIinh
                _lhsInt
                _lhsIo_unbox
                _lhsIsyn ->
                  (let _lhsOgathAltAttrs :: ([AltAttr])
                       _lhsOnts :: (Seq (Identifier,NontermIdent))
                       _lhsOinhs :: (Seq (Identifier,Attributes))
                       _lhsOcollectChildrenSyns :: (Map Identifier Attributes )
                       _lhsOcollectChildrenInhs :: (Map Identifier Attributes )
                       _lhsOsinglevisits :: ([CRule])
                       _lhsOterminals :: ([Identifier])
                       _lhsOattributes :: ([(Identifier,Attributes,Attributes)])
                       _lhsOfield :: ((Identifier,Type,Bool))
                       _lhsOerrors :: (Seq Error)
                       _lhsOgathRules :: (Seq CRule)
                       -- "Order.ag"(line 157, column 13)
                       _maptolocal =
                           ({-# LINE 157 "Order.ag" #-}
                            case tp_ of
                              NT nt _ -> Map.null syn_
                              _       -> True
                            {-# LINE 312 "Order.hs" #-})
                       -- "Order.ag"(line 160, column 13)
                       _lhsOgathAltAttrs =
                           ({-# LINE 160 "Order.ag" #-}
                            if  _maptolocal
                                then [ AltAttr _LOC name_ True ]
                                else [ AltAttr name_ syn True | syn <- Map.keys syn_ ]
                            {-# LINE 319 "Order.hs" #-})
                       -- "Order.ag"(line 175, column 13)
                       _lhsOnts =
                           ({-# LINE 175 "Order.ag" #-}
                            Seq.singleton (name_,getNtName tp_)
                            {-# LINE 324 "Order.hs" #-})
                       -- "Order.ag"(line 176, column 13)
                       _lhsOinhs =
                           ({-# LINE 176 "Order.ag" #-}
                            Seq.singleton (name_,inh_)
                            {-# LINE 329 "Order.hs" #-})
                       -- "Order.ag"(line 192, column 13)
                       _gathRules =
                           ({-# LINE 192 "Order.ag" #-}
                            if  _maptolocal
                                then Seq.singleton (cRuleTerminal name_ _lhsInt _lhsIcon tp_)
                                else Seq.fromList [ cRuleRhsSyn syn _lhsInt _lhsIcon tp name_ (getNtName tp_) | (syn,tp) <- Map.assocs syn_]
                            {-# LINE 336 "Order.hs" #-})
                       -- "Order.ag"(line 326, column 12)
                       _lhsOcollectChildrenSyns =
                           ({-# LINE 326 "Order.ag" #-}
                            Map.singleton name_ syn_
                            {-# LINE 341 "Order.hs" #-})
                       -- "Order.ag"(line 327, column 12)
                       _lhsOcollectChildrenInhs =
                           ({-# LINE 327 "Order.ag" #-}
                            Map.singleton name_ inh_
                            {-# LINE 346 "Order.hs" #-})
                       -- "Order.ag"(line 537, column 11)
                       _lhsOsinglevisits =
                           ({-# LINE 537 "Order.ag" #-}
                            if  _maptolocal
                                then []
                                else [CChildVisit name_ (getNtName tp_) 0 inh_ syn_ True]
                            {-# LINE 353 "Order.hs" #-})
                       -- "Order.ag"(line 561, column 11)
                       _lhsOterminals =
                           ({-# LINE 561 "Order.ag" #-}
                            if _maptolocal
                            then [name_]
                            else []
                            {-# LINE 360 "Order.hs" #-})
                       -- "Order.ag"(line 590, column 11)
                       _lhsOattributes =
                           ({-# LINE 590 "Order.ag" #-}
                            [(name_, inh_, syn_)]
                            {-# LINE 365 "Order.hs" #-})
                       -- "Order.ag"(line 594, column 11)
                       _lhsOfield =
                           ({-# LINE 594 "Order.ag" #-}
                            (name_, tp_, higherOrder_)
                            {-# LINE 370 "Order.hs" #-})
                       -- use rule "Order.ag"(line 64, column 70)
                       _lhsOerrors =
                           ({-# LINE 64 "Order.ag" #-}
                            Seq.empty
                            {-# LINE 375 "Order.hs" #-})
                       -- use rule "Order.ag"(line 186, column 23)
                       _lhsOgathRules =
                           ({-# LINE 186 "Order.ag" #-}
                            _gathRules
                            {-# LINE 380 "Order.hs" #-})
                   in  ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfield,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals))) )
-- Children ----------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allfields            : [(Identifier,Type,Bool)]
         allnts               : [Identifier]
         attrs                : [(Identifier,Identifier)]
         con                  : Identifier
         inh                  : Attributes
         nt                   : Identifier
         o_unbox              : Bool
         syn                  : Attributes
      synthesized attributes:
         attributes           : [(Identifier,Attributes,Attributes)]
         collectChildrenInhs  : Map Identifier Attributes 
         collectChildrenSyns  : Map Identifier Attributes 
         errors               : Seq Error
         fields               : [(Identifier,Type,Bool)]
         gathAltAttrs         : [AltAttr]
         gathRules            : Seq CRule
         inhs                 : Seq (Identifier,Attributes)
         nts                  : Seq (Identifier,NontermIdent)
         singlevisits         : [CRule]
         terminals            : [Identifier]
   alternatives:
      alternative Cons:
         child hd             : Child 
         child tl             : Children 
      alternative Nil:
-}
-- cata
sem_Children :: Children  ->
                T_Children 
sem_Children list  =
    (Prelude.foldr sem_Children_Cons sem_Children_Nil (Prelude.map sem_Child list) )
-- semantic domain
newtype T_Children  = T_Children (([(Identifier,Type,Bool)]) ->
                                  ([Identifier]) ->
                                  ([(Identifier,Identifier)]) ->
                                  Identifier ->
                                  Attributes ->
                                  Identifier ->
                                  Bool ->
                                  Attributes ->
                                  ( ([(Identifier,Attributes,Attributes)]),(Map Identifier Attributes ),(Map Identifier Attributes ),(Seq Error),([(Identifier,Type,Bool)]),([AltAttr]),(Seq CRule),(Seq (Identifier,Attributes)),(Seq (Identifier,NontermIdent)),([CRule]),([Identifier])))
data Inh_Children  = Inh_Children {allfields_Inh_Children :: !(([(Identifier,Type,Bool)])),allnts_Inh_Children :: !(([Identifier])),attrs_Inh_Children :: !(([(Identifier,Identifier)])),con_Inh_Children :: !(Identifier),inh_Inh_Children :: !(Attributes),nt_Inh_Children :: !(Identifier),o_unbox_Inh_Children :: !(Bool),syn_Inh_Children :: !(Attributes)}
data Syn_Children  = Syn_Children {attributes_Syn_Children :: !(([(Identifier,Attributes,Attributes)])),collectChildrenInhs_Syn_Children :: !((Map Identifier Attributes )),collectChildrenSyns_Syn_Children :: !((Map Identifier Attributes )),errors_Syn_Children :: !((Seq Error)),fields_Syn_Children :: !(([(Identifier,Type,Bool)])),gathAltAttrs_Syn_Children :: !(([AltAttr])),gathRules_Syn_Children :: !((Seq CRule)),inhs_Syn_Children :: !((Seq (Identifier,Attributes))),nts_Syn_Children :: !((Seq (Identifier,NontermIdent))),singlevisits_Syn_Children :: !(([CRule])),terminals_Syn_Children :: !(([Identifier]))}
wrap_Children :: T_Children  ->
                 Inh_Children  ->
                 Syn_Children 
wrap_Children (T_Children sem ) (Inh_Children _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn )  =
    (let ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfields,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals) =
             (sem _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsIinh _lhsInt _lhsIo_unbox _lhsIsyn )
     in  (Syn_Children _lhsOattributes _lhsOcollectChildrenInhs _lhsOcollectChildrenSyns _lhsOerrors _lhsOfields _lhsOgathAltAttrs _lhsOgathRules _lhsOinhs _lhsOnts _lhsOsinglevisits _lhsOterminals ))
sem_Children_Cons :: T_Child  ->
                     T_Children  ->
                     T_Children 
sem_Children_Cons (T_Child hd_ ) (T_Children tl_ )  =
    (T_Children (\ _lhsIallfields
                   _lhsIallnts
                   _lhsIattrs
                   _lhsIcon
                   _lhsIinh
                   _lhsInt
                   _lhsIo_unbox
                   _lhsIsyn ->
                     (let _lhsOfields :: ([(Identifier,Type,Bool)])
                          _lhsOattributes :: ([(Identifier,Attributes,Attributes)])
                          _lhsOcollectChildrenInhs :: (Map Identifier Attributes )
                          _lhsOcollectChildrenSyns :: (Map Identifier Attributes )
                          _lhsOerrors :: (Seq Error)
                          _lhsOgathAltAttrs :: ([AltAttr])
                          _lhsOgathRules :: (Seq CRule)
                          _lhsOinhs :: (Seq (Identifier,Attributes))
                          _lhsOnts :: (Seq (Identifier,NontermIdent))
                          _lhsOsinglevisits :: ([CRule])
                          _lhsOterminals :: ([Identifier])
                          _hdOallfields :: ([(Identifier,Type,Bool)])
                          _hdOallnts :: ([Identifier])
                          _hdOattrs :: ([(Identifier,Identifier)])
                          _hdOcon :: Identifier
                          _hdOinh :: Attributes
                          _hdOnt :: Identifier
                          _hdOo_unbox :: Bool
                          _hdOsyn :: Attributes
                          _tlOallfields :: ([(Identifier,Type,Bool)])
                          _tlOallnts :: ([Identifier])
                          _tlOattrs :: ([(Identifier,Identifier)])
                          _tlOcon :: Identifier
                          _tlOinh :: Attributes
                          _tlOnt :: Identifier
                          _tlOo_unbox :: Bool
                          _tlOsyn :: Attributes
                          _hdIattributes :: ([(Identifier,Attributes,Attributes)])
                          _hdIcollectChildrenInhs :: (Map Identifier Attributes )
                          _hdIcollectChildrenSyns :: (Map Identifier Attributes )
                          _hdIerrors :: (Seq Error)
                          _hdIfield :: ((Identifier,Type,Bool))
                          _hdIgathAltAttrs :: ([AltAttr])
                          _hdIgathRules :: (Seq CRule)
                          _hdIinhs :: (Seq (Identifier,Attributes))
                          _hdInts :: (Seq (Identifier,NontermIdent))
                          _hdIsinglevisits :: ([CRule])
                          _hdIterminals :: ([Identifier])
                          _tlIattributes :: ([(Identifier,Attributes,Attributes)])
                          _tlIcollectChildrenInhs :: (Map Identifier Attributes )
                          _tlIcollectChildrenSyns :: (Map Identifier Attributes )
                          _tlIerrors :: (Seq Error)
                          _tlIfields :: ([(Identifier,Type,Bool)])
                          _tlIgathAltAttrs :: ([AltAttr])
                          _tlIgathRules :: (Seq CRule)
                          _tlIinhs :: (Seq (Identifier,Attributes))
                          _tlInts :: (Seq (Identifier,NontermIdent))
                          _tlIsinglevisits :: ([CRule])
                          _tlIterminals :: ([Identifier])
                          -- "Order.ag"(line 597, column 11)
                          _lhsOfields =
                              ({-# LINE 597 "Order.ag" #-}
                               _hdIfield : _tlIfields
                               {-# LINE 501 "Order.hs" #-})
                          -- use rule "Order.ag"(line 588, column 32)
                          _lhsOattributes =
                              ({-# LINE 588 "Order.ag" #-}
                               _hdIattributes ++ _tlIattributes
                               {-# LINE 506 "Order.hs" #-})
                          -- use rule "Order.ag"(line 324, column 68)
                          _lhsOcollectChildrenInhs =
                              ({-# LINE 324 "Order.ag" #-}
                               _hdIcollectChildrenInhs `Map.union` _tlIcollectChildrenInhs
                               {-# LINE 511 "Order.hs" #-})
                          -- use rule "Order.ag"(line 324, column 68)
                          _lhsOcollectChildrenSyns =
                              ({-# LINE 324 "Order.ag" #-}
                               _hdIcollectChildrenSyns `Map.union` _tlIcollectChildrenSyns
                               {-# LINE 516 "Order.hs" #-})
                          -- use rule "Order.ag"(line 64, column 70)
                          _lhsOerrors =
                              ({-# LINE 64 "Order.ag" #-}
                               _hdIerrors Seq.>< _tlIerrors
                               {-# LINE 521 "Order.hs" #-})
                          -- use rule "Order.ag"(line 150, column 68)
                          _lhsOgathAltAttrs =
                              ({-# LINE 150 "Order.ag" #-}
                               _hdIgathAltAttrs ++ _tlIgathAltAttrs
                               {-# LINE 526 "Order.hs" #-})
                          -- use rule "Order.ag"(line 186, column 23)
                          _lhsOgathRules =
                              ({-# LINE 186 "Order.ag" #-}
                               _hdIgathRules Seq.>< _tlIgathRules
                               {-# LINE 531 "Order.hs" #-})
                          -- use rule "Order.ag"(line 173, column 20)
                          _lhsOinhs =
                              ({-# LINE 173 "Order.ag" #-}
                               _hdIinhs Seq.>< _tlIinhs
                               {-# LINE 536 "Order.hs" #-})
                          -- use rule "Order.ag"(line 172, column 19)
                          _lhsOnts =
                              ({-# LINE 172 "Order.ag" #-}
                               _hdInts Seq.>< _tlInts
                               {-# LINE 541 "Order.hs" #-})
                          -- use rule "Order.ag"(line 535, column 40)
                          _lhsOsinglevisits =
                              ({-# LINE 535 "Order.ag" #-}
                               _hdIsinglevisits ++ _tlIsinglevisits
                               {-# LINE 546 "Order.hs" #-})
                          -- use rule "Order.ag"(line 559, column 38)
                          _lhsOterminals =
                              ({-# LINE 559 "Order.ag" #-}
                               _hdIterminals ++ _tlIterminals
                               {-# LINE 551 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOallfields =
                              ({-# LINE 577 "Order.ag" #-}
                               _lhsIallfields
                               {-# LINE 556 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOallnts =
                              ({-# LINE 570 "Order.ag" #-}
                               _lhsIallnts
                               {-# LINE 561 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOattrs =
                              ({-# LINE 577 "Order.ag" #-}
                               _lhsIattrs
                               {-# LINE 566 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOcon =
                              ({-# LINE 70 "Order.ag" #-}
                               _lhsIcon
                               {-# LINE 571 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOinh =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIinh
                               {-# LINE 576 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOnt =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsInt
                               {-# LINE 581 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOo_unbox =
                              ({-# LINE 99 "Order.ag" #-}
                               _lhsIo_unbox
                               {-# LINE 586 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOsyn =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIsyn
                               {-# LINE 591 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOallfields =
                              ({-# LINE 577 "Order.ag" #-}
                               _lhsIallfields
                               {-# LINE 596 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOallnts =
                              ({-# LINE 570 "Order.ag" #-}
                               _lhsIallnts
                               {-# LINE 601 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOattrs =
                              ({-# LINE 577 "Order.ag" #-}
                               _lhsIattrs
                               {-# LINE 606 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOcon =
                              ({-# LINE 70 "Order.ag" #-}
                               _lhsIcon
                               {-# LINE 611 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOinh =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIinh
                               {-# LINE 616 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOnt =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsInt
                               {-# LINE 621 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOo_unbox =
                              ({-# LINE 99 "Order.ag" #-}
                               _lhsIo_unbox
                               {-# LINE 626 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOsyn =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIsyn
                               {-# LINE 631 "Order.hs" #-})
                          ( _hdIattributes,_hdIcollectChildrenInhs,_hdIcollectChildrenSyns,_hdIerrors,_hdIfield,_hdIgathAltAttrs,_hdIgathRules,_hdIinhs,_hdInts,_hdIsinglevisits,_hdIterminals) =
                              (hd_ _hdOallfields _hdOallnts _hdOattrs _hdOcon _hdOinh _hdOnt _hdOo_unbox _hdOsyn )
                          ( _tlIattributes,_tlIcollectChildrenInhs,_tlIcollectChildrenSyns,_tlIerrors,_tlIfields,_tlIgathAltAttrs,_tlIgathRules,_tlIinhs,_tlInts,_tlIsinglevisits,_tlIterminals) =
                              (tl_ _tlOallfields _tlOallnts _tlOattrs _tlOcon _tlOinh _tlOnt _tlOo_unbox _tlOsyn )
                      in  ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfields,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals))) )
sem_Children_Nil :: T_Children 
sem_Children_Nil  =
    (T_Children (\ _lhsIallfields
                   _lhsIallnts
                   _lhsIattrs
                   _lhsIcon
                   _lhsIinh
                   _lhsInt
                   _lhsIo_unbox
                   _lhsIsyn ->
                     (let _lhsOfields :: ([(Identifier,Type,Bool)])
                          _lhsOattributes :: ([(Identifier,Attributes,Attributes)])
                          _lhsOcollectChildrenInhs :: (Map Identifier Attributes )
                          _lhsOcollectChildrenSyns :: (Map Identifier Attributes )
                          _lhsOerrors :: (Seq Error)
                          _lhsOgathAltAttrs :: ([AltAttr])
                          _lhsOgathRules :: (Seq CRule)
                          _lhsOinhs :: (Seq (Identifier,Attributes))
                          _lhsOnts :: (Seq (Identifier,NontermIdent))
                          _lhsOsinglevisits :: ([CRule])
                          _lhsOterminals :: ([Identifier])
                          -- "Order.ag"(line 598, column 11)
                          _lhsOfields =
                              ({-# LINE 598 "Order.ag" #-}
                               []
                               {-# LINE 662 "Order.hs" #-})
                          -- use rule "Order.ag"(line 588, column 32)
                          _lhsOattributes =
                              ({-# LINE 588 "Order.ag" #-}
                               []
                               {-# LINE 667 "Order.hs" #-})
                          -- use rule "Order.ag"(line 324, column 68)
                          _lhsOcollectChildrenInhs =
                              ({-# LINE 324 "Order.ag" #-}
                               Map.empty
                               {-# LINE 672 "Order.hs" #-})
                          -- use rule "Order.ag"(line 324, column 68)
                          _lhsOcollectChildrenSyns =
                              ({-# LINE 324 "Order.ag" #-}
                               Map.empty
                               {-# LINE 677 "Order.hs" #-})
                          -- use rule "Order.ag"(line 64, column 70)
                          _lhsOerrors =
                              ({-# LINE 64 "Order.ag" #-}
                               Seq.empty
                               {-# LINE 682 "Order.hs" #-})
                          -- use rule "Order.ag"(line 150, column 68)
                          _lhsOgathAltAttrs =
                              ({-# LINE 150 "Order.ag" #-}
                               []
                               {-# LINE 687 "Order.hs" #-})
                          -- use rule "Order.ag"(line 186, column 23)
                          _lhsOgathRules =
                              ({-# LINE 186 "Order.ag" #-}
                               Seq.empty
                               {-# LINE 692 "Order.hs" #-})
                          -- use rule "Order.ag"(line 173, column 20)
                          _lhsOinhs =
                              ({-# LINE 173 "Order.ag" #-}
                               Seq.empty
                               {-# LINE 697 "Order.hs" #-})
                          -- use rule "Order.ag"(line 172, column 19)
                          _lhsOnts =
                              ({-# LINE 172 "Order.ag" #-}
                               Seq.empty
                               {-# LINE 702 "Order.hs" #-})
                          -- use rule "Order.ag"(line 535, column 40)
                          _lhsOsinglevisits =
                              ({-# LINE 535 "Order.ag" #-}
                               []
                               {-# LINE 707 "Order.hs" #-})
                          -- use rule "Order.ag"(line 559, column 38)
                          _lhsOterminals =
                              ({-# LINE 559 "Order.ag" #-}
                               []
                               {-# LINE 712 "Order.hs" #-})
                      in  ( _lhsOattributes,_lhsOcollectChildrenInhs,_lhsOcollectChildrenSyns,_lhsOerrors,_lhsOfields,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinhs,_lhsOnts,_lhsOsinglevisits,_lhsOterminals))) )
-- Expression --------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allfields            : [(Identifier,Type,Bool)]
         allnts               : [Identifier]
         attrs                : [(Identifier,Identifier)]
         con                  : Identifier
         nt                   : Identifier
      synthesized attributes:
         allRhsVars           : Set (Identifier,Identifier)
         copy                 : SELF 
         errors               : Seq Error
         textLines            : [String]
         usedAttrs            : [(Identifier,Identifier)]
         usedFields           : [Identifier]
         usedLocals           : [Identifier]
   alternatives:
      alternative Expression:
         child pos            : {Pos}
         child tks            : {[HsToken]}
         visit 0:
            local _tup1       : _
            local errors      : _
            local textLines   : _
            local usedAttrs   : _
            local usedLocals  : _
            local usedFields  : _
            local copy        : _
-}
-- cata
sem_Expression :: Expression  ->
                  T_Expression 
sem_Expression (Expression _pos _tks )  =
    (sem_Expression_Expression _pos _tks )
-- semantic domain
newtype T_Expression  = T_Expression (([(Identifier,Type,Bool)]) ->
                                      ([Identifier]) ->
                                      ([(Identifier,Identifier)]) ->
                                      Identifier ->
                                      Identifier ->
                                      ( (Set (Identifier,Identifier)),Expression ,(Seq Error),([String]),([(Identifier,Identifier)]),([Identifier]),([Identifier])))
data Inh_Expression  = Inh_Expression {allfields_Inh_Expression :: !(([(Identifier,Type,Bool)])),allnts_Inh_Expression :: !(([Identifier])),attrs_Inh_Expression :: !(([(Identifier,Identifier)])),con_Inh_Expression :: !(Identifier),nt_Inh_Expression :: !(Identifier)}
data Syn_Expression  = Syn_Expression {allRhsVars_Syn_Expression :: !((Set (Identifier,Identifier))),copy_Syn_Expression :: !(Expression ),errors_Syn_Expression :: !((Seq Error)),textLines_Syn_Expression :: !(([String])),usedAttrs_Syn_Expression :: !(([(Identifier,Identifier)])),usedFields_Syn_Expression :: !(([Identifier])),usedLocals_Syn_Expression :: !(([Identifier]))}
wrap_Expression :: T_Expression  ->
                   Inh_Expression  ->
                   Syn_Expression 
wrap_Expression (T_Expression sem ) (Inh_Expression _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsInt )  =
    (let ( _lhsOallRhsVars,_lhsOcopy,_lhsOerrors,_lhsOtextLines,_lhsOusedAttrs,_lhsOusedFields,_lhsOusedLocals) =
             (sem _lhsIallfields _lhsIallnts _lhsIattrs _lhsIcon _lhsInt )
     in  (Syn_Expression _lhsOallRhsVars _lhsOcopy _lhsOerrors _lhsOtextLines _lhsOusedAttrs _lhsOusedFields _lhsOusedLocals ))
sem_Expression_Expression :: Pos ->
                             ([HsToken]) ->
                             T_Expression 
sem_Expression_Expression pos_ tks_  =
    (T_Expression (\ _lhsIallfields
                     _lhsIallnts
                     _lhsIattrs
                     _lhsIcon
                     _lhsInt ->
                       (let _lhsOallRhsVars :: (Set (Identifier,Identifier))
                            _lhsOcopy :: Expression 
                            _lhsOerrors :: (Seq Error)
                            _lhsOtextLines :: ([String])
                            _lhsOusedAttrs :: ([(Identifier,Identifier)])
                            _lhsOusedFields :: ([Identifier])
                            _lhsOusedLocals :: ([Identifier])
                            -- "Order.ag"(line 396, column 21)
                            __tup1 =
                                ({-# LINE 396 "Order.ag" #-}
                                 let inherited = Inh_HsTokensRoot
                                                 { attrs_Inh_HsTokensRoot      = _lhsIattrs
                                                 , con_Inh_HsTokensRoot        = _lhsIcon
                                                 , allfields_Inh_HsTokensRoot  = _lhsIallfields
                                                 , allnts_Inh_HsTokensRoot     = _lhsIallnts
                                                 , nt_Inh_HsTokensRoot         = _lhsInt
                                                 }
                                     synthesized = wrap_HsTokensRoot (sem_HsTokensRoot (HsTokensRoot tks_)) inherited
                                 in case synthesized of
                                      Syn_HsTokensRoot
                                       { errors_Syn_HsTokensRoot     = errors
                                       , textLines_Syn_HsTokensRoot  = textLines
                                       , usedAttrs_Syn_HsTokensRoot  = usedAttrs
                                       , usedLocals_Syn_HsTokensRoot = usedLocals
                                       , usedFields_Syn_HsTokensRoot = usedFields
                                       }  -> (errors,textLines,usedAttrs,usedLocals,usedFields)
                                 {-# LINE 800 "Order.hs" #-})
                            -- "Order.ag"(line 396, column 21)
                            (_errors,_,_,_,_) =
                                ({-# LINE 396 "Order.ag" #-}
                                 __tup1
                                 {-# LINE 805 "Order.hs" #-})
                            -- "Order.ag"(line 396, column 21)
                            (_,_textLines,_,_,_) =
                                ({-# LINE 396 "Order.ag" #-}
                                 __tup1
                                 {-# LINE 810 "Order.hs" #-})
                            -- "Order.ag"(line 396, column 21)
                            (_,_,_usedAttrs,_,_) =
                                ({-# LINE 396 "Order.ag" #-}
                                 __tup1
                                 {-# LINE 815 "Order.hs" #-})
                            -- "Order.ag"(line 396, column 21)
                            (_,_,_,_usedLocals,_) =
                                ({-# LINE 396 "Order.ag" #-}
                                 __tup1
                                 {-# LINE 820 "Order.hs" #-})
                            -- "Order.ag"(line 396, column 21)
                            (_,_,_,_,_usedFields) =
                                ({-# LINE 396 "Order.ag" #-}
                                 __tup1
                                 {-# LINE 825 "Order.hs" #-})
                            -- "Order.ag"(line 414, column 17)
                            _lhsOallRhsVars =
                                ({-# LINE 414 "Order.ag" #-}
                                 Set.fromList _usedAttrs
                                 `Set.union`
                                 Set.fromList [ (_LOC, l) | l <- _usedLocals    ]
                                 `Set.union`
                                 Set.fromList [ (_FIELD, fld) | fld <- _usedFields    ]
                                 {-# LINE 834 "Order.hs" #-})
                            -- self rule
                            _copy =
                                ({-# LINE 391 "Order.ag" #-}
                                 Expression pos_ tks_
                                 {-# LINE 839 "Order.hs" #-})
                            -- self rule
                            _lhsOcopy =
                                ({-# LINE 391 "Order.ag" #-}
                                 _copy
                                 {-# LINE 844 "Order.hs" #-})
                            -- copy rule (from local)
                            _lhsOerrors =
                                ({-# LINE 386 "Order.ag" #-}
                                 _errors
                                 {-# LINE 849 "Order.hs" #-})
                            -- copy rule (from local)
                            _lhsOtextLines =
                                ({-# LINE 390 "Order.ag" #-}
                                 _textLines
                                 {-# LINE 854 "Order.hs" #-})
                            -- copy rule (from local)
                            _lhsOusedAttrs =
                                ({-# LINE 388 "Order.ag" #-}
                                 _usedAttrs
                                 {-# LINE 859 "Order.hs" #-})
                            -- copy rule (from local)
                            _lhsOusedFields =
                                ({-# LINE 389 "Order.ag" #-}
                                 _usedFields
                                 {-# LINE 864 "Order.hs" #-})
                            -- copy rule (from local)
                            _lhsOusedLocals =
                                ({-# LINE 387 "Order.ag" #-}
                                 _usedLocals
                                 {-# LINE 869 "Order.hs" #-})
                        in  ( _lhsOallRhsVars,_lhsOcopy,_lhsOerrors,_lhsOtextLines,_lhsOusedAttrs,_lhsOusedFields,_lhsOusedLocals))) )
-- Grammar -----------------------------------------------------
{-
   visit 0:
      inherited attribute:
         options              : Options
      synthesized attributes:
         errors               : Seq Error
         output               : CGrammar
   alternatives:
      alternative Grammar:
         child typeSyns       : {TypeSyns}
         child useMap         : {UseMap}
         child derivings      : {Derivings}
         child wrappers       : {Set NontermIdent}
         child nonts          : Nonterminals 
         child pragmas        : {PragmaMap}
         child manualAttrOrderMap : {AttrOrderMap}
         child paramMap       : {ParamMap}
         child contextMap     : {ContextMap}
         child uniqueMap      : {UniqueMap}
         child augmentsMap    : {Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))}
         child aroundsMap     : {Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))}
         visit 0:
            local ruleTable   : _
            local attrTable   : _
            local attrVertex  : _
            local tdpToTds    : _
            local tdsToTdp    : _
            local directDep   : _
            local instDep     : _
            local aroundDep   : _
            local info        : _
            local _tup2       : _
            local cInterfaceMap : _
            local cVisitsMap  : _
            local cyclesErrors : _
            local aroundMap   : _
-}
-- cata
sem_Grammar :: Grammar  ->
               T_Grammar 
sem_Grammar (Grammar _typeSyns _useMap _derivings _wrappers _nonts _pragmas _manualAttrOrderMap _paramMap _contextMap _uniqueMap _augmentsMap _aroundsMap )  =
    (sem_Grammar_Grammar _typeSyns _useMap _derivings _wrappers (sem_Nonterminals _nonts ) _pragmas _manualAttrOrderMap _paramMap _contextMap _uniqueMap _augmentsMap _aroundsMap )
-- semantic domain
newtype T_Grammar  = T_Grammar (Options ->
                                ( (Seq Error),CGrammar))
data Inh_Grammar  = Inh_Grammar {options_Inh_Grammar :: !(Options)}
data Syn_Grammar  = Syn_Grammar {errors_Syn_Grammar :: !((Seq Error)),output_Syn_Grammar :: !(CGrammar)}
wrap_Grammar :: T_Grammar  ->
                Inh_Grammar  ->
                Syn_Grammar 
wrap_Grammar (T_Grammar sem ) (Inh_Grammar _lhsIoptions )  =
    (let ( _lhsOerrors,_lhsOoutput) =
             (sem _lhsIoptions )
     in  (Syn_Grammar _lhsOerrors _lhsOoutput ))
sem_Grammar_Grammar :: TypeSyns ->
                       UseMap ->
                       Derivings ->
                       (Set NontermIdent) ->
                       T_Nonterminals  ->
                       PragmaMap ->
                       AttrOrderMap ->
                       ParamMap ->
                       ContextMap ->
                       UniqueMap ->
                       (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
                       (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
                       T_Grammar 
sem_Grammar_Grammar typeSyns_ useMap_ derivings_ wrappers_ (T_Nonterminals nonts_ ) pragmas_ manualAttrOrderMap_ paramMap_ contextMap_ uniqueMap_ augmentsMap_ aroundsMap_  =
    (T_Grammar (\ _lhsIoptions ->
                    (let _nontsOo_cata :: Bool
                         _nontsOo_data :: Bool
                         _nontsOo_sig :: Bool
                         _nontsOo_sem :: Bool
                         _nontsOo_rename :: Bool
                         _nontsOo_newtypes :: Bool
                         _nontsOo_wantvisit :: Bool
                         _nontsOo_dovisit :: Bool
                         _nontsOo_unbox :: Bool
                         _nontsOo_case :: Bool
                         _nontsOprefix :: String
                         _nontsOvcount :: Int
                         _nontsOmanualAttrDepMap :: AttrOrderMap
                         _nontsOaroundMap :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])))
                         _nontsOacount :: Int
                         _lhsOerrors :: (Seq Error)
                         _lhsOoutput :: CGrammar
                         _nontsOallnts :: ([Identifier])
                         _nontsOcInterfaceMap :: CInterfaceMap
                         _nontsOcVisitsMap :: CVisitsMap
                         _nontsIacount :: Int
                         _nontsIadditionalDep :: (Seq Edge)
                         _nontsIaranges :: (Seq (Int,Int,Int))
                         _nontsIaroundDep :: (Seq Edge)
                         _nontsIcNonterminals :: CNonterminals
                         _nontsIdirectDep :: (Seq Edge)
                         _nontsIerrors :: (Seq Error)
                         _nontsIinstDep :: (Seq Edge)
                         _nontsInonts :: ([(NontermIdent,[ConstructorIdent])])
                         _nontsIntattrs :: (Seq (Vertex,NTAttr))
                         _nontsIrules :: (Seq (Vertex,CRule))
                         _nontsIvcount :: Int
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_cata =
                             ({-# LINE 103 "Order.ag" #-}
                              folds     _lhsIoptions
                              {-# LINE 977 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_data =
                             ({-# LINE 104 "Order.ag" #-}
                              dataTypes _lhsIoptions
                              {-# LINE 982 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_sig =
                             ({-# LINE 105 "Order.ag" #-}
                              typeSigs  _lhsIoptions
                              {-# LINE 987 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_sem =
                             ({-# LINE 106 "Order.ag" #-}
                              semfuns   _lhsIoptions
                              {-# LINE 992 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_rename =
                             ({-# LINE 107 "Order.ag" #-}
                              rename    _lhsIoptions
                              {-# LINE 997 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_newtypes =
                             ({-# LINE 108 "Order.ag" #-}
                              newtypes  _lhsIoptions
                              {-# LINE 1002 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_wantvisit =
                             ({-# LINE 109 "Order.ag" #-}
                              visit   _lhsIoptions
                              {-# LINE 1007 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_dovisit =
                             ({-# LINE 110 "Order.ag" #-}
                              visit     _lhsIoptions && null _cyclesErrors
                              {-# LINE 1012 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_unbox =
                             ({-# LINE 111 "Order.ag" #-}
                              unbox     _lhsIoptions
                              {-# LINE 1017 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOo_case =
                             ({-# LINE 112 "Order.ag" #-}
                              cases     _lhsIoptions
                              {-# LINE 1022 "Order.hs" #-})
                         -- "Order.ag"(line 103, column 17)
                         _nontsOprefix =
                             ({-# LINE 113 "Order.ag" #-}
                              prefix    _lhsIoptions
                              {-# LINE 1027 "Order.hs" #-})
                         -- "Order.ag"(line 241, column 15)
                         _nontsOvcount =
                             ({-# LINE 241 "Order.ag" #-}
                              0
                              {-# LINE 1032 "Order.hs" #-})
                         -- "Order.ag"(line 267, column 7)
                         _nontsOmanualAttrDepMap =
                             ({-# LINE 267 "Order.ag" #-}
                              manualAttrOrderMap_
                              {-# LINE 1037 "Order.hs" #-})
                         -- "Order.ag"(line 350, column 14)
                         _nontsOaroundMap =
                             ({-# LINE 350 "Order.ag" #-}
                              aroundsMap_
                              {-# LINE 1042 "Order.hs" #-})
                         -- "Order.ag"(line 428, column 13)
                         _nontsOacount =
                             ({-# LINE 428 "Order.ag" #-}
                              0
                              {-# LINE 1047 "Order.hs" #-})
                         -- "Order.ag"(line 466, column 13)
                         _ruleTable =
                             ({-# LINE 466 "Order.ag" #-}
                              Array.array (0,_nontsIvcount-1) (toList _nontsIrules)
                              {-# LINE 1052 "Order.hs" #-})
                         -- "Order.ag"(line 467, column 13)
                         _attrTable =
                             ({-# LINE 467 "Order.ag" #-}
                              Array.array (0,_nontsIacount-1) (toList _nontsIntattrs)
                              {-# LINE 1057 "Order.hs" #-})
                         -- "Order.ag"(line 468, column 13)
                         _attrVertex =
                             ({-# LINE 468 "Order.ag" #-}
                              Map.fromList (map swap (toList _nontsIntattrs))
                              {-# LINE 1062 "Order.hs" #-})
                         -- "Order.ag"(line 469, column 13)
                         _tdpToTds =
                             ({-# LINE 469 "Order.ag" #-}
                              [ (s, maybe (-1) (\v -> findWithErr1 "Grammar.tdpToTds" v _attrVertex) (ntattr cr))
                              | (s,cr) <- toList _nontsIrules]
                              {-# LINE 1068 "Order.hs" #-})
                         -- "Order.ag"(line 471, column 13)
                         _tdsToTdp =
                             ({-# LINE 471 "Order.ag" #-}
                              let  eq (_,v) (_,v') = v == v'
                                   conv ((s,v):svs)  | v == -1 = Nothing
                                                     | otherwise = Just (v,s:map fst svs)
                              in mapMaybe conv (eqClasses eq _tdpToTds)
                              {-# LINE 1076 "Order.hs" #-})
                         -- "Order.ag"(line 475, column 13)
                         _directDep =
                             ({-# LINE 475 "Order.ag" #-}
                              toList (_nontsIdirectDep Seq.>< _nontsIadditionalDep)
                              {-# LINE 1081 "Order.hs" #-})
                         -- "Order.ag"(line 476, column 13)
                         _instDep =
                             ({-# LINE 476 "Order.ag" #-}
                              toList _nontsIinstDep
                              {-# LINE 1086 "Order.hs" #-})
                         -- "Order.ag"(line 477, column 13)
                         _aroundDep =
                             ({-# LINE 477 "Order.ag" #-}
                              toList _nontsIaroundDep
                              {-# LINE 1091 "Order.hs" #-})
                         -- "Order.ag"(line 478, column 13)
                         _info =
                             ({-# LINE 478 "Order.ag" #-}
                              let def [] = -1
                                  def (v:vs) = v
                               in Info { tdsToTdp   = Array.array (0,_nontsIacount-1) _tdsToTdp
                                       , tdpToTds   = Array.array (0,_nontsIvcount-1) _tdpToTds
                                       , attrTable  = _attrTable
                                       , ruleTable  = _ruleTable
                                       , lmh        = toList _nontsIaranges
                                       , nonts      = _nontsInonts
                                       , wraps      = wrappers_
                                       }
                              {-# LINE 1105 "Order.hs" #-})
                         -- "Order.ag"(line 489, column 17)
                         __tup2 =
                             ({-# LINE 489 "Order.ag" #-}
                              case computeSequential _info _directDep (_instDep ++ _aroundDep) of
                                           CycleFree    cim cvm   -> ( cim
                                                                     , cvm
                                                                     , []
                                                                     )
                                           LocalCycle   errs      -> ( error "No interfaces for AG with local cycles"
                                                                     , error "No visit sub-sequences for AG with local cycles"
                                                                     , map (localCycleErr _ruleTable (visit _lhsIoptions)) errs
                                                                     )
                                           InstCycle    errs      -> ( error "No interfaces for AG with cycles through insts"
                                                                     , error "No visit sub-sequences for AG with cycles through insts"
                                                                     , map (instCycleErr _ruleTable (visit _lhsIoptions)) errs
                                                                     )
                                           DirectCycle  errs      -> ( error "No interfaces for AG with direct cycles"
                                                                     , error "No visit sub-sequences for AG with direct cycles"
                                                                     , directCycleErrs _attrTable _ruleTable (visit _lhsIoptions) errs
                                                                     )
                                           InducedCycle cim errs ->  ( cim
                                                                     , error "No visit sub-sequences for AG with induced cycles"
                                                                     , inducedCycleErrs _attrTable _ruleTable cim errs
                                                                     )
                              {-# LINE 1130 "Order.hs" #-})
                         -- "Order.ag"(line 489, column 17)
                         (_cInterfaceMap,_,_) =
                             ({-# LINE 489 "Order.ag" #-}
                              __tup2
                              {-# LINE 1135 "Order.hs" #-})
                         -- "Order.ag"(line 489, column 17)
                         (_,_cVisitsMap,_) =
                             ({-# LINE 489 "Order.ag" #-}
                              __tup2
                              {-# LINE 1140 "Order.hs" #-})
                         -- "Order.ag"(line 489, column 17)
                         (_,_,_cyclesErrors) =
                             ({-# LINE 489 "Order.ag" #-}
                              __tup2
                              {-# LINE 1145 "Order.hs" #-})
                         -- "Order.ag"(line 511, column 13)
                         _lhsOerrors =
                             ({-# LINE 511 "Order.ag" #-}
                              (if withCycle _lhsIoptions then Seq.fromList _cyclesErrors else Seq.empty)
                              Seq.>< _nontsIerrors
                              {-# LINE 1151 "Order.hs" #-})
                         -- "Order.ag"(line 543, column 15)
                         _lhsOoutput =
                             ({-# LINE 543 "Order.ag" #-}
                              CGrammar typeSyns_ derivings_ wrappers_ _nontsIcNonterminals pragmas_ paramMap_ contextMap_ _aroundMap
                              {-# LINE 1156 "Order.hs" #-})
                         -- "Order.ag"(line 556, column 14)
                         _aroundMap =
                             ({-# LINE 556 "Order.ag" #-}
                              Map.map (Map.map Map.keysSet) aroundsMap_
                              {-# LINE 1161 "Order.hs" #-})
                         -- "Order.ag"(line 573, column 13)
                         _nontsOallnts =
                             ({-# LINE 573 "Order.ag" #-}
                              map fst (_nontsInonts)
                              {-# LINE 1166 "Order.hs" #-})
                         -- copy rule (from local)
                         _nontsOcInterfaceMap =
                             ({-# LINE 518 "Order.ag" #-}
                              _cInterfaceMap
                              {-# LINE 1171 "Order.hs" #-})
                         -- copy rule (from local)
                         _nontsOcVisitsMap =
                             ({-# LINE 525 "Order.ag" #-}
                              _cVisitsMap
                              {-# LINE 1176 "Order.hs" #-})
                         ( _nontsIacount,_nontsIadditionalDep,_nontsIaranges,_nontsIaroundDep,_nontsIcNonterminals,_nontsIdirectDep,_nontsIerrors,_nontsIinstDep,_nontsInonts,_nontsIntattrs,_nontsIrules,_nontsIvcount) =
                             (nonts_ _nontsOacount _nontsOallnts _nontsOaroundMap _nontsOcInterfaceMap _nontsOcVisitsMap _nontsOmanualAttrDepMap _nontsOo_case _nontsOo_cata _nontsOo_data _nontsOo_dovisit _nontsOo_newtypes _nontsOo_rename _nontsOo_sem _nontsOo_sig _nontsOo_unbox _nontsOo_wantvisit _nontsOprefix _nontsOvcount )
                     in  ( _lhsOerrors,_lhsOoutput))) )
-- Nonterminal -------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allnts               : [Identifier]
         aroundMap            : Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
         cInterfaceMap        : CInterfaceMap
         cVisitsMap           : CVisitsMap
         manualAttrDepMap     : AttrOrderMap
         o_case               : Bool
         o_cata               : Bool
         o_data               : Bool
         o_dovisit            : Bool
         o_newtypes           : Bool
         o_rename             : Bool
         o_sem                : Bool
         o_sig                : Bool
         o_unbox              : Bool
         o_wantvisit          : Bool
         prefix               : String
      chained attributes:
         acount               : Int
         vcount               : Int
      synthesized attributes:
         additionalDep        : Seq Edge
         aranges              : Seq (Int,Int,Int)
         aroundDep            : Seq Edge
         cNonterminal         : CNonterminal
         directDep            : Seq Edge
         errors               : Seq Error
         instDep              : Seq Edge
         nonts                : [(NontermIdent,[ConstructorIdent])]
         ntattrs              : Seq (Vertex,NTAttr)
         rules                : Seq (Vertex,CRule)
   alternatives:
      alternative Nonterminal:
         child nt             : {NontermIdent}
         child params         : {[Identifier]}
         child inh            : {Attributes}
         child syn            : {Attributes}
         child prods          : Productions 
         visit 0:
            local aroundMap   : _
            local ntattrs     : _
            local cInter      : _
-}
-- cata
sem_Nonterminal :: Nonterminal  ->
                   T_Nonterminal 
sem_Nonterminal (Nonterminal _nt _params _inh _syn _prods )  =
    (sem_Nonterminal_Nonterminal _nt _params _inh _syn (sem_Productions _prods ) )
-- semantic domain
newtype T_Nonterminal  = T_Nonterminal (Int ->
                                        ([Identifier]) ->
                                        (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
                                        CInterfaceMap ->
                                        CVisitsMap ->
                                        AttrOrderMap ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        String ->
                                        Int ->
                                        ( Int,(Seq Edge),(Seq (Int,Int,Int)),(Seq Edge),CNonterminal,(Seq Edge),(Seq Error),(Seq Edge),([(NontermIdent,[ConstructorIdent])]),(Seq (Vertex,NTAttr)),(Seq (Vertex,CRule)),Int))
data Inh_Nonterminal  = Inh_Nonterminal {acount_Inh_Nonterminal :: !(Int),allnts_Inh_Nonterminal :: !(([Identifier])),aroundMap_Inh_Nonterminal :: !((Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])))),cInterfaceMap_Inh_Nonterminal :: !(CInterfaceMap),cVisitsMap_Inh_Nonterminal :: !(CVisitsMap),manualAttrDepMap_Inh_Nonterminal :: !(AttrOrderMap),o_case_Inh_Nonterminal :: !(Bool),o_cata_Inh_Nonterminal :: !(Bool),o_data_Inh_Nonterminal :: !(Bool),o_dovisit_Inh_Nonterminal :: !(Bool),o_newtypes_Inh_Nonterminal :: !(Bool),o_rename_Inh_Nonterminal :: !(Bool),o_sem_Inh_Nonterminal :: !(Bool),o_sig_Inh_Nonterminal :: !(Bool),o_unbox_Inh_Nonterminal :: !(Bool),o_wantvisit_Inh_Nonterminal :: !(Bool),prefix_Inh_Nonterminal :: !(String),vcount_Inh_Nonterminal :: !(Int)}
data Syn_Nonterminal  = Syn_Nonterminal {acount_Syn_Nonterminal :: !(Int),additionalDep_Syn_Nonterminal :: !((Seq Edge)),aranges_Syn_Nonterminal :: !((Seq (Int,Int,Int))),aroundDep_Syn_Nonterminal :: !((Seq Edge)),cNonterminal_Syn_Nonterminal :: !(CNonterminal),directDep_Syn_Nonterminal :: !((Seq Edge)),errors_Syn_Nonterminal :: !((Seq Error)),instDep_Syn_Nonterminal :: !((Seq Edge)),nonts_Syn_Nonterminal :: !(([(NontermIdent,[ConstructorIdent])])),ntattrs_Syn_Nonterminal :: !((Seq (Vertex,NTAttr))),rules_Syn_Nonterminal :: !((Seq (Vertex,CRule))),vcount_Syn_Nonterminal :: !(Int)}
wrap_Nonterminal :: T_Nonterminal  ->
                    Inh_Nonterminal  ->
                    Syn_Nonterminal 
wrap_Nonterminal (T_Nonterminal sem ) (Inh_Nonterminal _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount )  =
    (let ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminal,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount) =
             (sem _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount )
     in  (Syn_Nonterminal _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminal _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOnonts _lhsOntattrs _lhsOrules _lhsOvcount ))
sem_Nonterminal_Nonterminal :: NontermIdent ->
                               ([Identifier]) ->
                               Attributes ->
                               Attributes ->
                               T_Productions  ->
                               T_Nonterminal 
sem_Nonterminal_Nonterminal nt_ params_ inh_ syn_ (T_Productions prods_ )  =
    (T_Nonterminal (\ _lhsIacount
                      _lhsIallnts
                      _lhsIaroundMap
                      _lhsIcInterfaceMap
                      _lhsIcVisitsMap
                      _lhsImanualAttrDepMap
                      _lhsIo_case
                      _lhsIo_cata
                      _lhsIo_data
                      _lhsIo_dovisit
                      _lhsIo_newtypes
                      _lhsIo_rename
                      _lhsIo_sem
                      _lhsIo_sig
                      _lhsIo_unbox
                      _lhsIo_wantvisit
                      _lhsIprefix
                      _lhsIvcount ->
                        (let _prodsOnt :: Identifier
                             _prodsOinh :: Attributes
                             _prodsOsyn :: Attributes
                             _lhsOntattrs :: (Seq (Vertex,NTAttr))
                             _lhsOacount :: Int
                             _lhsOaranges :: (Seq (Int,Int,Int))
                             _lhsOnonts :: ([(NontermIdent,[ConstructorIdent])])
                             _lhsOcNonterminal :: CNonterminal
                             _lhsOadditionalDep :: (Seq Edge)
                             _lhsOaroundDep :: (Seq Edge)
                             _lhsOdirectDep :: (Seq Edge)
                             _lhsOerrors :: (Seq Error)
                             _lhsOinstDep :: (Seq Edge)
                             _lhsOrules :: (Seq (Vertex,CRule))
                             _lhsOvcount :: Int
                             _prodsOallnts :: ([Identifier])
                             _prodsOaroundMap :: (Map ConstructorIdent (Map Identifier [Expression]))
                             _prodsOcVisitsMap :: CVisitsMap
                             _prodsOmanualAttrDepMap :: AttrOrderMap
                             _prodsOo_case :: Bool
                             _prodsOo_cata :: Bool
                             _prodsOo_dovisit :: Bool
                             _prodsOo_newtypes :: Bool
                             _prodsOo_rename :: Bool
                             _prodsOo_sem :: Bool
                             _prodsOo_sig :: Bool
                             _prodsOo_unbox :: Bool
                             _prodsOo_wantvisit :: Bool
                             _prodsOprefix :: String
                             _prodsOvcount :: Int
                             _prodsIadditionalDep :: (Seq Edge)
                             _prodsIaroundDep :: (Seq Edge)
                             _prodsIcProductions :: CProductions
                             _prodsIcons :: ([ConstructorIdent])
                             _prodsIdirectDep :: (Seq Edge)
                             _prodsIerrors :: (Seq Error)
                             _prodsIinstDep :: (Seq Edge)
                             _prodsIrules :: (Seq (Vertex,CRule))
                             _prodsIvcount :: Int
                             -- "Order.ag"(line 77, column 17)
                             _prodsOnt =
                                 ({-# LINE 77 "Order.ag" #-}
                                  nt_
                                  {-# LINE 1328 "Order.hs" #-})
                             -- "Order.ag"(line 80, column 17)
                             _prodsOinh =
                                 ({-# LINE 80 "Order.ag" #-}
                                  inh_
                                  {-# LINE 1333 "Order.hs" #-})
                             -- "Order.ag"(line 81, column 17)
                             _prodsOsyn =
                                 ({-# LINE 81 "Order.ag" #-}
                                  syn_
                                  {-# LINE 1338 "Order.hs" #-})
                             -- "Order.ag"(line 346, column 32)
                             _aroundMap =
                                 ({-# LINE 346 "Order.ag" #-}
                                  Map.findWithDefault Map.empty nt_ _lhsIaroundMap
                                  {-# LINE 1343 "Order.hs" #-})
                             -- "Order.ag"(line 431, column 17)
                             _ntattrs =
                                 ({-# LINE 431 "Order.ag" #-}
                                  [ NTAInh nt_ inh tp | (inh,tp) <- Map.assocs inh_ ]
                                  ++ [NTASyn nt_ syn tp | (syn,tp) <- Map.assocs syn_ ]
                                  {-# LINE 1349 "Order.hs" #-})
                             -- "Order.ag"(line 433, column 17)
                             _lhsOntattrs =
                                 ({-# LINE 433 "Order.ag" #-}
                                  Seq.fromList (zip [_lhsIacount ..] _ntattrs)
                                  {-# LINE 1354 "Order.hs" #-})
                             -- "Order.ag"(line 434, column 17)
                             _lhsOacount =
                                 ({-# LINE 434 "Order.ag" #-}
                                  _lhsIacount + Map.size inh_ + Map.size syn_
                                  {-# LINE 1359 "Order.hs" #-})
                             -- "Order.ag"(line 435, column 17)
                             _lhsOaranges =
                                 ({-# LINE 435 "Order.ag" #-}
                                  Seq.singleton
                                   (_lhsIacount
                                   ,_lhsIacount + Map.size inh_
                                   ,_lhsIacount + Map.size syn_ + Map.size inh_ - 1)
                                  {-# LINE 1367 "Order.hs" #-})
                             -- "Order.ag"(line 444, column 19)
                             _lhsOnonts =
                                 ({-# LINE 444 "Order.ag" #-}
                                  [(nt_,_prodsIcons)]
                                  {-# LINE 1372 "Order.hs" #-})
                             -- "Order.ag"(line 520, column 19)
                             _cInter =
                                 ({-# LINE 520 "Order.ag" #-}
                                  if  _lhsIo_dovisit
                                         then findWithErr1 "Nonterminal.cInter" nt_ _lhsIcInterfaceMap
                                         else CInterface [CSegment inh_ syn_]
                                  {-# LINE 1379 "Order.hs" #-})
                             -- "Order.ag"(line 548, column 19)
                             _lhsOcNonterminal =
                                 ({-# LINE 548 "Order.ag" #-}
                                  CNonterminal nt_ params_ inh_ syn_ _prodsIcProductions _cInter
                                  {-# LINE 1384 "Order.hs" #-})
                             -- use rule "Order.ag"(line 263, column 60)
                             _lhsOadditionalDep =
                                 ({-# LINE 263 "Order.ag" #-}
                                  _prodsIadditionalDep
                                  {-# LINE 1389 "Order.hs" #-})
                             -- use rule "Order.ag"(line 338, column 24)
                             _lhsOaroundDep =
                                 ({-# LINE 338 "Order.ag" #-}
                                  _prodsIaroundDep
                                  {-# LINE 1394 "Order.hs" #-})
                             -- use rule "Order.ag"(line 249, column 33)
                             _lhsOdirectDep =
                                 ({-# LINE 249 "Order.ag" #-}
                                  _prodsIdirectDep
                                  {-# LINE 1399 "Order.hs" #-})
                             -- use rule "Order.ag"(line 64, column 70)
                             _lhsOerrors =
                                 ({-# LINE 64 "Order.ag" #-}
                                  _prodsIerrors
                                  {-# LINE 1404 "Order.hs" #-})
                             -- use rule "Order.ag"(line 292, column 31)
                             _lhsOinstDep =
                                 ({-# LINE 292 "Order.ag" #-}
                                  _prodsIinstDep
                                  {-# LINE 1409 "Order.hs" #-})
                             -- use rule "Order.ag"(line 239, column 18)
                             _lhsOrules =
                                 ({-# LINE 239 "Order.ag" #-}
                                  _prodsIrules
                                  {-# LINE 1414 "Order.hs" #-})
                             -- copy rule (up)
                             _lhsOvcount =
                                 ({-# LINE 238 "Order.ag" #-}
                                  _prodsIvcount
                                  {-# LINE 1419 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOallnts =
                                 ({-# LINE 570 "Order.ag" #-}
                                  _lhsIallnts
                                  {-# LINE 1424 "Order.hs" #-})
                             -- copy rule (from local)
                             _prodsOaroundMap =
                                 ({-# LINE 344 "Order.ag" #-}
                                  _aroundMap
                                  {-# LINE 1429 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOcVisitsMap =
                                 ({-# LINE 525 "Order.ag" #-}
                                  _lhsIcVisitsMap
                                  {-# LINE 1434 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOmanualAttrDepMap =
                                 ({-# LINE 263 "Order.ag" #-}
                                  _lhsImanualAttrDepMap
                                  {-# LINE 1439 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_case =
                                 ({-# LINE 97 "Order.ag" #-}
                                  _lhsIo_case
                                  {-# LINE 1444 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_cata =
                                 ({-# LINE 91 "Order.ag" #-}
                                  _lhsIo_cata
                                  {-# LINE 1449 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_dovisit =
                                 ({-# LINE 96 "Order.ag" #-}
                                  _lhsIo_dovisit
                                  {-# LINE 1454 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_newtypes =
                                 ({-# LINE 90 "Order.ag" #-}
                                  _lhsIo_newtypes
                                  {-# LINE 1459 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_rename =
                                 ({-# LINE 94 "Order.ag" #-}
                                  _lhsIo_rename
                                  {-# LINE 1464 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_sem =
                                 ({-# LINE 93 "Order.ag" #-}
                                  _lhsIo_sem
                                  {-# LINE 1469 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_sig =
                                 ({-# LINE 92 "Order.ag" #-}
                                  _lhsIo_sig
                                  {-# LINE 1474 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_unbox =
                                 ({-# LINE 99 "Order.ag" #-}
                                  _lhsIo_unbox
                                  {-# LINE 1479 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOo_wantvisit =
                                 ({-# LINE 95 "Order.ag" #-}
                                  _lhsIo_wantvisit
                                  {-# LINE 1484 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOprefix =
                                 ({-# LINE 98 "Order.ag" #-}
                                  _lhsIprefix
                                  {-# LINE 1489 "Order.hs" #-})
                             -- copy rule (down)
                             _prodsOvcount =
                                 ({-# LINE 238 "Order.ag" #-}
                                  _lhsIvcount
                                  {-# LINE 1494 "Order.hs" #-})
                             ( _prodsIadditionalDep,_prodsIaroundDep,_prodsIcProductions,_prodsIcons,_prodsIdirectDep,_prodsIerrors,_prodsIinstDep,_prodsIrules,_prodsIvcount) =
                                 (prods_ _prodsOallnts _prodsOaroundMap _prodsOcVisitsMap _prodsOinh _prodsOmanualAttrDepMap _prodsOnt _prodsOo_case _prodsOo_cata _prodsOo_dovisit _prodsOo_newtypes _prodsOo_rename _prodsOo_sem _prodsOo_sig _prodsOo_unbox _prodsOo_wantvisit _prodsOprefix _prodsOsyn _prodsOvcount )
                         in  ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminal,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount))) )
-- Nonterminals ------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allnts               : [Identifier]
         aroundMap            : Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
         cInterfaceMap        : CInterfaceMap
         cVisitsMap           : CVisitsMap
         manualAttrDepMap     : AttrOrderMap
         o_case               : Bool
         o_cata               : Bool
         o_data               : Bool
         o_dovisit            : Bool
         o_newtypes           : Bool
         o_rename             : Bool
         o_sem                : Bool
         o_sig                : Bool
         o_unbox              : Bool
         o_wantvisit          : Bool
         prefix               : String
      chained attributes:
         acount               : Int
         vcount               : Int
      synthesized attributes:
         additionalDep        : Seq Edge
         aranges              : Seq (Int,Int,Int)
         aroundDep            : Seq Edge
         cNonterminals        : CNonterminals
         directDep            : Seq Edge
         errors               : Seq Error
         instDep              : Seq Edge
         nonts                : [(NontermIdent,[ConstructorIdent])]
         ntattrs              : Seq (Vertex,NTAttr)
         rules                : Seq (Vertex,CRule)
   alternatives:
      alternative Cons:
         child hd             : Nonterminal 
         child tl             : Nonterminals 
      alternative Nil:
-}
-- cata
sem_Nonterminals :: Nonterminals  ->
                    T_Nonterminals 
sem_Nonterminals list  =
    (Prelude.foldr sem_Nonterminals_Cons sem_Nonterminals_Nil (Prelude.map sem_Nonterminal list) )
-- semantic domain
newtype T_Nonterminals  = T_Nonterminals (Int ->
                                          ([Identifier]) ->
                                          (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
                                          CInterfaceMap ->
                                          CVisitsMap ->
                                          AttrOrderMap ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          Bool ->
                                          String ->
                                          Int ->
                                          ( Int,(Seq Edge),(Seq (Int,Int,Int)),(Seq Edge),CNonterminals,(Seq Edge),(Seq Error),(Seq Edge),([(NontermIdent,[ConstructorIdent])]),(Seq (Vertex,NTAttr)),(Seq (Vertex,CRule)),Int))
data Inh_Nonterminals  = Inh_Nonterminals {acount_Inh_Nonterminals :: !(Int),allnts_Inh_Nonterminals :: !(([Identifier])),aroundMap_Inh_Nonterminals :: !((Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])))),cInterfaceMap_Inh_Nonterminals :: !(CInterfaceMap),cVisitsMap_Inh_Nonterminals :: !(CVisitsMap),manualAttrDepMap_Inh_Nonterminals :: !(AttrOrderMap),o_case_Inh_Nonterminals :: !(Bool),o_cata_Inh_Nonterminals :: !(Bool),o_data_Inh_Nonterminals :: !(Bool),o_dovisit_Inh_Nonterminals :: !(Bool),o_newtypes_Inh_Nonterminals :: !(Bool),o_rename_Inh_Nonterminals :: !(Bool),o_sem_Inh_Nonterminals :: !(Bool),o_sig_Inh_Nonterminals :: !(Bool),o_unbox_Inh_Nonterminals :: !(Bool),o_wantvisit_Inh_Nonterminals :: !(Bool),prefix_Inh_Nonterminals :: !(String),vcount_Inh_Nonterminals :: !(Int)}
data Syn_Nonterminals  = Syn_Nonterminals {acount_Syn_Nonterminals :: !(Int),additionalDep_Syn_Nonterminals :: !((Seq Edge)),aranges_Syn_Nonterminals :: !((Seq (Int,Int,Int))),aroundDep_Syn_Nonterminals :: !((Seq Edge)),cNonterminals_Syn_Nonterminals :: !(CNonterminals),directDep_Syn_Nonterminals :: !((Seq Edge)),errors_Syn_Nonterminals :: !((Seq Error)),instDep_Syn_Nonterminals :: !((Seq Edge)),nonts_Syn_Nonterminals :: !(([(NontermIdent,[ConstructorIdent])])),ntattrs_Syn_Nonterminals :: !((Seq (Vertex,NTAttr))),rules_Syn_Nonterminals :: !((Seq (Vertex,CRule))),vcount_Syn_Nonterminals :: !(Int)}
wrap_Nonterminals :: T_Nonterminals  ->
                     Inh_Nonterminals  ->
                     Syn_Nonterminals 
wrap_Nonterminals (T_Nonterminals sem ) (Inh_Nonterminals _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount )  =
    (let ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminals,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount) =
             (sem _lhsIacount _lhsIallnts _lhsIaroundMap _lhsIcInterfaceMap _lhsIcVisitsMap _lhsImanualAttrDepMap _lhsIo_case _lhsIo_cata _lhsIo_data _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIvcount )
     in  (Syn_Nonterminals _lhsOacount _lhsOadditionalDep _lhsOaranges _lhsOaroundDep _lhsOcNonterminals _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOnonts _lhsOntattrs _lhsOrules _lhsOvcount ))
sem_Nonterminals_Cons :: T_Nonterminal  ->
                         T_Nonterminals  ->
                         T_Nonterminals 
sem_Nonterminals_Cons (T_Nonterminal hd_ ) (T_Nonterminals tl_ )  =
    (T_Nonterminals (\ _lhsIacount
                       _lhsIallnts
                       _lhsIaroundMap
                       _lhsIcInterfaceMap
                       _lhsIcVisitsMap
                       _lhsImanualAttrDepMap
                       _lhsIo_case
                       _lhsIo_cata
                       _lhsIo_data
                       _lhsIo_dovisit
                       _lhsIo_newtypes
                       _lhsIo_rename
                       _lhsIo_sem
                       _lhsIo_sig
                       _lhsIo_unbox
                       _lhsIo_wantvisit
                       _lhsIprefix
                       _lhsIvcount ->
                         (let _lhsOcNonterminals :: CNonterminals
                              _lhsOadditionalDep :: (Seq Edge)
                              _lhsOaranges :: (Seq (Int,Int,Int))
                              _lhsOaroundDep :: (Seq Edge)
                              _lhsOdirectDep :: (Seq Edge)
                              _lhsOerrors :: (Seq Error)
                              _lhsOinstDep :: (Seq Edge)
                              _lhsOnonts :: ([(NontermIdent,[ConstructorIdent])])
                              _lhsOntattrs :: (Seq (Vertex,NTAttr))
                              _lhsOrules :: (Seq (Vertex,CRule))
                              _lhsOacount :: Int
                              _lhsOvcount :: Int
                              _hdOacount :: Int
                              _hdOallnts :: ([Identifier])
                              _hdOaroundMap :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])))
                              _hdOcInterfaceMap :: CInterfaceMap
                              _hdOcVisitsMap :: CVisitsMap
                              _hdOmanualAttrDepMap :: AttrOrderMap
                              _hdOo_case :: Bool
                              _hdOo_cata :: Bool
                              _hdOo_data :: Bool
                              _hdOo_dovisit :: Bool
                              _hdOo_newtypes :: Bool
                              _hdOo_rename :: Bool
                              _hdOo_sem :: Bool
                              _hdOo_sig :: Bool
                              _hdOo_unbox :: Bool
                              _hdOo_wantvisit :: Bool
                              _hdOprefix :: String
                              _hdOvcount :: Int
                              _tlOacount :: Int
                              _tlOallnts :: ([Identifier])
                              _tlOaroundMap :: (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression])))
                              _tlOcInterfaceMap :: CInterfaceMap
                              _tlOcVisitsMap :: CVisitsMap
                              _tlOmanualAttrDepMap :: AttrOrderMap
                              _tlOo_case :: Bool
                              _tlOo_cata :: Bool
                              _tlOo_data :: Bool
                              _tlOo_dovisit :: Bool
                              _tlOo_newtypes :: Bool
                              _tlOo_rename :: Bool
                              _tlOo_sem :: Bool
                              _tlOo_sig :: Bool
                              _tlOo_unbox :: Bool
                              _tlOo_wantvisit :: Bool
                              _tlOprefix :: String
                              _tlOvcount :: Int
                              _hdIacount :: Int
                              _hdIadditionalDep :: (Seq Edge)
                              _hdIaranges :: (Seq (Int,Int,Int))
                              _hdIaroundDep :: (Seq Edge)
                              _hdIcNonterminal :: CNonterminal
                              _hdIdirectDep :: (Seq Edge)
                              _hdIerrors :: (Seq Error)
                              _hdIinstDep :: (Seq Edge)
                              _hdInonts :: ([(NontermIdent,[ConstructorIdent])])
                              _hdIntattrs :: (Seq (Vertex,NTAttr))
                              _hdIrules :: (Seq (Vertex,CRule))
                              _hdIvcount :: Int
                              _tlIacount :: Int
                              _tlIadditionalDep :: (Seq Edge)
                              _tlIaranges :: (Seq (Int,Int,Int))
                              _tlIaroundDep :: (Seq Edge)
                              _tlIcNonterminals :: CNonterminals
                              _tlIdirectDep :: (Seq Edge)
                              _tlIerrors :: (Seq Error)
                              _tlIinstDep :: (Seq Edge)
                              _tlInonts :: ([(NontermIdent,[ConstructorIdent])])
                              _tlIntattrs :: (Seq (Vertex,NTAttr))
                              _tlIrules :: (Seq (Vertex,CRule))
                              _tlIvcount :: Int
                              -- "Order.ag"(line 545, column 12)
                              _lhsOcNonterminals =
                                  ({-# LINE 545 "Order.ag" #-}
                                   _hdIcNonterminal : _tlIcNonterminals
                                   {-# LINE 1670 "Order.hs" #-})
                              -- use rule "Order.ag"(line 263, column 60)
                              _lhsOadditionalDep =
                                  ({-# LINE 263 "Order.ag" #-}
                                   _hdIadditionalDep Seq.>< _tlIadditionalDep
                                   {-# LINE 1675 "Order.hs" #-})
                              -- use rule "Order.ag"(line 425, column 36)
                              _lhsOaranges =
                                  ({-# LINE 425 "Order.ag" #-}
                                   _hdIaranges Seq.>< _tlIaranges
                                   {-# LINE 1680 "Order.hs" #-})
                              -- use rule "Order.ag"(line 338, column 24)
                              _lhsOaroundDep =
                                  ({-# LINE 338 "Order.ag" #-}
                                   _hdIaroundDep Seq.>< _tlIaroundDep
                                   {-# LINE 1685 "Order.hs" #-})
                              -- use rule "Order.ag"(line 249, column 33)
                              _lhsOdirectDep =
                                  ({-# LINE 249 "Order.ag" #-}
                                   _hdIdirectDep Seq.>< _tlIdirectDep
                                   {-# LINE 1690 "Order.hs" #-})
                              -- use rule "Order.ag"(line 64, column 70)
                              _lhsOerrors =
                                  ({-# LINE 64 "Order.ag" #-}
                                   _hdIerrors Seq.>< _tlIerrors
                                   {-# LINE 1695 "Order.hs" #-})
                              -- use rule "Order.ag"(line 292, column 31)
                              _lhsOinstDep =
                                  ({-# LINE 292 "Order.ag" #-}
                                   _hdIinstDep Seq.>< _tlIinstDep
                                   {-# LINE 1700 "Order.hs" #-})
                              -- use rule "Order.ag"(line 442, column 43)
                              _lhsOnonts =
                                  ({-# LINE 442 "Order.ag" #-}
                                   _hdInonts ++ _tlInonts
                                   {-# LINE 1705 "Order.hs" #-})
                              -- use rule "Order.ag"(line 424, column 35)
                              _lhsOntattrs =
                                  ({-# LINE 424 "Order.ag" #-}
                                   _hdIntattrs Seq.>< _tlIntattrs
                                   {-# LINE 1710 "Order.hs" #-})
                              -- use rule "Order.ag"(line 239, column 18)
                              _lhsOrules =
                                  ({-# LINE 239 "Order.ag" #-}
                                   _hdIrules Seq.>< _tlIrules
                                   {-# LINE 1715 "Order.hs" #-})
                              -- copy rule (up)
                              _lhsOacount =
                                  ({-# LINE 424 "Order.ag" #-}
                                   _tlIacount
                                   {-# LINE 1720 "Order.hs" #-})
                              -- copy rule (up)
                              _lhsOvcount =
                                  ({-# LINE 238 "Order.ag" #-}
                                   _tlIvcount
                                   {-# LINE 1725 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOacount =
                                  ({-# LINE 424 "Order.ag" #-}
                                   _lhsIacount
                                   {-# LINE 1730 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOallnts =
                                  ({-# LINE 570 "Order.ag" #-}
                                   _lhsIallnts
                                   {-# LINE 1735 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOaroundMap =
                                  ({-# LINE 341 "Order.ag" #-}
                                   _lhsIaroundMap
                                   {-# LINE 1740 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOcInterfaceMap =
                                  ({-# LINE 518 "Order.ag" #-}
                                   _lhsIcInterfaceMap
                                   {-# LINE 1745 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOcVisitsMap =
                                  ({-# LINE 525 "Order.ag" #-}
                                   _lhsIcVisitsMap
                                   {-# LINE 1750 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOmanualAttrDepMap =
                                  ({-# LINE 263 "Order.ag" #-}
                                   _lhsImanualAttrDepMap
                                   {-# LINE 1755 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_case =
                                  ({-# LINE 97 "Order.ag" #-}
                                   _lhsIo_case
                                   {-# LINE 1760 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_cata =
                                  ({-# LINE 91 "Order.ag" #-}
                                   _lhsIo_cata
                                   {-# LINE 1765 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_data =
                                  ({-# LINE 100 "Order.ag" #-}
                                   _lhsIo_data
                                   {-# LINE 1770 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_dovisit =
                                  ({-# LINE 96 "Order.ag" #-}
                                   _lhsIo_dovisit
                                   {-# LINE 1775 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_newtypes =
                                  ({-# LINE 90 "Order.ag" #-}
                                   _lhsIo_newtypes
                                   {-# LINE 1780 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_rename =
                                  ({-# LINE 94 "Order.ag" #-}
                                   _lhsIo_rename
                                   {-# LINE 1785 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_sem =
                                  ({-# LINE 93 "Order.ag" #-}
                                   _lhsIo_sem
                                   {-# LINE 1790 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_sig =
                                  ({-# LINE 92 "Order.ag" #-}
                                   _lhsIo_sig
                                   {-# LINE 1795 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_unbox =
                                  ({-# LINE 99 "Order.ag" #-}
                                   _lhsIo_unbox
                                   {-# LINE 1800 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOo_wantvisit =
                                  ({-# LINE 95 "Order.ag" #-}
                                   _lhsIo_wantvisit
                                   {-# LINE 1805 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOprefix =
                                  ({-# LINE 98 "Order.ag" #-}
                                   _lhsIprefix
                                   {-# LINE 1810 "Order.hs" #-})
                              -- copy rule (down)
                              _hdOvcount =
                                  ({-# LINE 238 "Order.ag" #-}
                                   _lhsIvcount
                                   {-# LINE 1815 "Order.hs" #-})
                              -- copy rule (chain)
                              _tlOacount =
                                  ({-# LINE 424 "Order.ag" #-}
                                   _hdIacount
                                   {-# LINE 1820 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOallnts =
                                  ({-# LINE 570 "Order.ag" #-}
                                   _lhsIallnts
                                   {-# LINE 1825 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOaroundMap =
                                  ({-# LINE 341 "Order.ag" #-}
                                   _lhsIaroundMap
                                   {-# LINE 1830 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOcInterfaceMap =
                                  ({-# LINE 518 "Order.ag" #-}
                                   _lhsIcInterfaceMap
                                   {-# LINE 1835 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOcVisitsMap =
                                  ({-# LINE 525 "Order.ag" #-}
                                   _lhsIcVisitsMap
                                   {-# LINE 1840 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOmanualAttrDepMap =
                                  ({-# LINE 263 "Order.ag" #-}
                                   _lhsImanualAttrDepMap
                                   {-# LINE 1845 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_case =
                                  ({-# LINE 97 "Order.ag" #-}
                                   _lhsIo_case
                                   {-# LINE 1850 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_cata =
                                  ({-# LINE 91 "Order.ag" #-}
                                   _lhsIo_cata
                                   {-# LINE 1855 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_data =
                                  ({-# LINE 100 "Order.ag" #-}
                                   _lhsIo_data
                                   {-# LINE 1860 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_dovisit =
                                  ({-# LINE 96 "Order.ag" #-}
                                   _lhsIo_dovisit
                                   {-# LINE 1865 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_newtypes =
                                  ({-# LINE 90 "Order.ag" #-}
                                   _lhsIo_newtypes
                                   {-# LINE 1870 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_rename =
                                  ({-# LINE 94 "Order.ag" #-}
                                   _lhsIo_rename
                                   {-# LINE 1875 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_sem =
                                  ({-# LINE 93 "Order.ag" #-}
                                   _lhsIo_sem
                                   {-# LINE 1880 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_sig =
                                  ({-# LINE 92 "Order.ag" #-}
                                   _lhsIo_sig
                                   {-# LINE 1885 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_unbox =
                                  ({-# LINE 99 "Order.ag" #-}
                                   _lhsIo_unbox
                                   {-# LINE 1890 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOo_wantvisit =
                                  ({-# LINE 95 "Order.ag" #-}
                                   _lhsIo_wantvisit
                                   {-# LINE 1895 "Order.hs" #-})
                              -- copy rule (down)
                              _tlOprefix =
                                  ({-# LINE 98 "Order.ag" #-}
                                   _lhsIprefix
                                   {-# LINE 1900 "Order.hs" #-})
                              -- copy rule (chain)
                              _tlOvcount =
                                  ({-# LINE 238 "Order.ag" #-}
                                   _hdIvcount
                                   {-# LINE 1905 "Order.hs" #-})
                              ( _hdIacount,_hdIadditionalDep,_hdIaranges,_hdIaroundDep,_hdIcNonterminal,_hdIdirectDep,_hdIerrors,_hdIinstDep,_hdInonts,_hdIntattrs,_hdIrules,_hdIvcount) =
                                  (hd_ _hdOacount _hdOallnts _hdOaroundMap _hdOcInterfaceMap _hdOcVisitsMap _hdOmanualAttrDepMap _hdOo_case _hdOo_cata _hdOo_data _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOprefix _hdOvcount )
                              ( _tlIacount,_tlIadditionalDep,_tlIaranges,_tlIaroundDep,_tlIcNonterminals,_tlIdirectDep,_tlIerrors,_tlIinstDep,_tlInonts,_tlIntattrs,_tlIrules,_tlIvcount) =
                                  (tl_ _tlOacount _tlOallnts _tlOaroundMap _tlOcInterfaceMap _tlOcVisitsMap _tlOmanualAttrDepMap _tlOo_case _tlOo_cata _tlOo_data _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOprefix _tlOvcount )
                          in  ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminals,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount))) )
sem_Nonterminals_Nil :: T_Nonterminals 
sem_Nonterminals_Nil  =
    (T_Nonterminals (\ _lhsIacount
                       _lhsIallnts
                       _lhsIaroundMap
                       _lhsIcInterfaceMap
                       _lhsIcVisitsMap
                       _lhsImanualAttrDepMap
                       _lhsIo_case
                       _lhsIo_cata
                       _lhsIo_data
                       _lhsIo_dovisit
                       _lhsIo_newtypes
                       _lhsIo_rename
                       _lhsIo_sem
                       _lhsIo_sig
                       _lhsIo_unbox
                       _lhsIo_wantvisit
                       _lhsIprefix
                       _lhsIvcount ->
                         (let _lhsOcNonterminals :: CNonterminals
                              _lhsOadditionalDep :: (Seq Edge)
                              _lhsOaranges :: (Seq (Int,Int,Int))
                              _lhsOaroundDep :: (Seq Edge)
                              _lhsOdirectDep :: (Seq Edge)
                              _lhsOerrors :: (Seq Error)
                              _lhsOinstDep :: (Seq Edge)
                              _lhsOnonts :: ([(NontermIdent,[ConstructorIdent])])
                              _lhsOntattrs :: (Seq (Vertex,NTAttr))
                              _lhsOrules :: (Seq (Vertex,CRule))
                              _lhsOacount :: Int
                              _lhsOvcount :: Int
                              -- "Order.ag"(line 546, column 12)
                              _lhsOcNonterminals =
                                  ({-# LINE 546 "Order.ag" #-}
                                   []
                                   {-# LINE 1947 "Order.hs" #-})
                              -- use rule "Order.ag"(line 263, column 60)
                              _lhsOadditionalDep =
                                  ({-# LINE 263 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1952 "Order.hs" #-})
                              -- use rule "Order.ag"(line 425, column 36)
                              _lhsOaranges =
                                  ({-# LINE 425 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1957 "Order.hs" #-})
                              -- use rule "Order.ag"(line 338, column 24)
                              _lhsOaroundDep =
                                  ({-# LINE 338 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1962 "Order.hs" #-})
                              -- use rule "Order.ag"(line 249, column 33)
                              _lhsOdirectDep =
                                  ({-# LINE 249 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1967 "Order.hs" #-})
                              -- use rule "Order.ag"(line 64, column 70)
                              _lhsOerrors =
                                  ({-# LINE 64 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1972 "Order.hs" #-})
                              -- use rule "Order.ag"(line 292, column 31)
                              _lhsOinstDep =
                                  ({-# LINE 292 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1977 "Order.hs" #-})
                              -- use rule "Order.ag"(line 442, column 43)
                              _lhsOnonts =
                                  ({-# LINE 442 "Order.ag" #-}
                                   []
                                   {-# LINE 1982 "Order.hs" #-})
                              -- use rule "Order.ag"(line 424, column 35)
                              _lhsOntattrs =
                                  ({-# LINE 424 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1987 "Order.hs" #-})
                              -- use rule "Order.ag"(line 239, column 18)
                              _lhsOrules =
                                  ({-# LINE 239 "Order.ag" #-}
                                   Seq.empty
                                   {-# LINE 1992 "Order.hs" #-})
                              -- copy rule (chain)
                              _lhsOacount =
                                  ({-# LINE 424 "Order.ag" #-}
                                   _lhsIacount
                                   {-# LINE 1997 "Order.hs" #-})
                              -- copy rule (chain)
                              _lhsOvcount =
                                  ({-# LINE 238 "Order.ag" #-}
                                   _lhsIvcount
                                   {-# LINE 2002 "Order.hs" #-})
                          in  ( _lhsOacount,_lhsOadditionalDep,_lhsOaranges,_lhsOaroundDep,_lhsOcNonterminals,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOnonts,_lhsOntattrs,_lhsOrules,_lhsOvcount))) )
-- Pattern -----------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allTypeSigs          : Map Identifier Type
         altAttrs             : Map AltAttr Vertex
         con                  : Identifier
         inh                  : Attributes
         nt                   : Identifier
         syn                  : Attributes
      synthesized attributes:
         copy                 : SELF 
         errors               : Seq Error
         gathAltAttrs         : [AltAttr]
         instVars             : [Identifier]
         locVars              : [Identifier]
         patternAttrs         : [(Identifier,Identifier,Bool,Patterns)]
   alternatives:
      alternative Alias:
         child field          : {Identifier}
         child attr           : {Identifier}
         child pat            : Pattern 
         child parts          : Patterns 
         visit 0:
            local copy        : _
      alternative Constr:
         child name           : {ConstructorIdent}
         child pats           : Patterns 
         visit 0:
            local copy        : _
      alternative Irrefutable:
         child pat            : Pattern 
         visit 0:
            local copy        : _
      alternative Product:
         child pos            : {Pos}
         child pats           : Patterns 
         visit 0:
            local copy        : _
      alternative Underscore:
         child pos            : {Pos}
         visit 0:
            local copy        : _
-}
-- cata
sem_Pattern :: Pattern  ->
               T_Pattern 
sem_Pattern (Alias _field _attr _pat _parts )  =
    (sem_Pattern_Alias _field _attr (sem_Pattern _pat ) (sem_Patterns _parts ) )
sem_Pattern (Constr _name _pats )  =
    (sem_Pattern_Constr _name (sem_Patterns _pats ) )
sem_Pattern (Irrefutable _pat )  =
    (sem_Pattern_Irrefutable (sem_Pattern _pat ) )
sem_Pattern (Product _pos _pats )  =
    (sem_Pattern_Product _pos (sem_Patterns _pats ) )
sem_Pattern (Underscore _pos )  =
    (sem_Pattern_Underscore _pos )
-- semantic domain
newtype T_Pattern  = T_Pattern ((Map Identifier Type) ->
                                (Map AltAttr Vertex) ->
                                Identifier ->
                                Attributes ->
                                Identifier ->
                                Attributes ->
                                ( Pattern ,(Seq Error),([AltAttr]),([Identifier]),([Identifier]),([(Identifier,Identifier,Bool,Patterns)])))
data Inh_Pattern  = Inh_Pattern {allTypeSigs_Inh_Pattern :: !((Map Identifier Type)),altAttrs_Inh_Pattern :: !((Map AltAttr Vertex)),con_Inh_Pattern :: !(Identifier),inh_Inh_Pattern :: !(Attributes),nt_Inh_Pattern :: !(Identifier),syn_Inh_Pattern :: !(Attributes)}
data Syn_Pattern  = Syn_Pattern {copy_Syn_Pattern :: !(Pattern ),errors_Syn_Pattern :: !((Seq Error)),gathAltAttrs_Syn_Pattern :: !(([AltAttr])),instVars_Syn_Pattern :: !(([Identifier])),locVars_Syn_Pattern :: !(([Identifier])),patternAttrs_Syn_Pattern :: !(([(Identifier,Identifier,Bool,Patterns)]))}
wrap_Pattern :: T_Pattern  ->
                Inh_Pattern  ->
                Syn_Pattern 
wrap_Pattern (T_Pattern sem ) (Inh_Pattern _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn )  =
    (let ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs) =
             (sem _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn )
     in  (Syn_Pattern _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs ))
sem_Pattern_Alias :: Identifier ->
                     Identifier ->
                     T_Pattern  ->
                     T_Patterns  ->
                     T_Pattern 
sem_Pattern_Alias field_ attr_ (T_Pattern pat_ ) (T_Patterns parts_ )  =
    (T_Pattern (\ _lhsIallTypeSigs
                  _lhsIaltAttrs
                  _lhsIcon
                  _lhsIinh
                  _lhsInt
                  _lhsIsyn ->
                    (let _lhsOgathAltAttrs :: ([AltAttr])
                         _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         _lhsOlocVars :: ([Identifier])
                         _lhsOinstVars :: ([Identifier])
                         _lhsOerrors :: (Seq Error)
                         _lhsOcopy :: Pattern 
                         _patOallTypeSigs :: (Map Identifier Type)
                         _patOaltAttrs :: (Map AltAttr Vertex)
                         _patOcon :: Identifier
                         _patOinh :: Attributes
                         _patOnt :: Identifier
                         _patOsyn :: Attributes
                         _partsOallTypeSigs :: (Map Identifier Type)
                         _partsOaltAttrs :: (Map AltAttr Vertex)
                         _partsOcon :: Identifier
                         _partsOinh :: Attributes
                         _partsOnt :: Identifier
                         _partsOsyn :: Attributes
                         _patIcopy :: Pattern 
                         _patIerrors :: (Seq Error)
                         _patIgathAltAttrs :: ([AltAttr])
                         _patIinstVars :: ([Identifier])
                         _patIlocVars :: ([Identifier])
                         _patIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         _partsIcopy :: Patterns 
                         _partsIerrors :: (Seq Error)
                         _partsIgathAltAttrs :: ([AltAttr])
                         _partsIinstVars :: ([Identifier])
                         _partsIlocVars :: ([Identifier])
                         _partsIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         -- "Order.ag"(line 164, column 12)
                         _lhsOgathAltAttrs =
                             ({-# LINE 164 "Order.ag" #-}
                              [AltAttr field_ attr_ (field_ == _LOC || field_ == _INST)]
                              {-# LINE 2124 "Order.hs" #-})
                         -- "Order.ag"(line 232, column 12)
                         _lhsOpatternAttrs =
                             ({-# LINE 232 "Order.ag" #-}
                              [(field_,attr_,(field_ == _LOC || field_ == _INST),_partsIcopy)]
                              {-# LINE 2129 "Order.hs" #-})
                         -- "Order.ag"(line 603, column 14)
                         _lhsOlocVars =
                             ({-# LINE 603 "Order.ag" #-}
                              if field_ == _LOC
                                 then [attr_]
                                 else []
                              {-# LINE 2136 "Order.hs" #-})
                         -- "Order.ag"(line 606, column 14)
                         _lhsOinstVars =
                             ({-# LINE 606 "Order.ag" #-}
                              if field_ == _INST
                                 then [attr_]
                                 else []
                              {-# LINE 2143 "Order.hs" #-})
                         -- use rule "Order.ag"(line 64, column 70)
                         _lhsOerrors =
                             ({-# LINE 64 "Order.ag" #-}
                              _patIerrors Seq.>< _partsIerrors
                              {-# LINE 2148 "Order.hs" #-})
                         -- self rule
                         _copy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              Alias field_ attr_ _patIcopy _partsIcopy
                              {-# LINE 2153 "Order.hs" #-})
                         -- self rule
                         _lhsOcopy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              _copy
                              {-# LINE 2158 "Order.hs" #-})
                         -- copy rule (down)
                         _patOallTypeSigs =
                             ({-# LINE 458 "Order.ag" #-}
                              _lhsIallTypeSigs
                              {-# LINE 2163 "Order.hs" #-})
                         -- copy rule (down)
                         _patOaltAttrs =
                             ({-# LINE 166 "Order.ag" #-}
                              _lhsIaltAttrs
                              {-# LINE 2168 "Order.hs" #-})
                         -- copy rule (down)
                         _patOcon =
                             ({-# LINE 70 "Order.ag" #-}
                              _lhsIcon
                              {-# LINE 2173 "Order.hs" #-})
                         -- copy rule (down)
                         _patOinh =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIinh
                              {-# LINE 2178 "Order.hs" #-})
                         -- copy rule (down)
                         _patOnt =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsInt
                              {-# LINE 2183 "Order.hs" #-})
                         -- copy rule (down)
                         _patOsyn =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIsyn
                              {-# LINE 2188 "Order.hs" #-})
                         -- copy rule (down)
                         _partsOallTypeSigs =
                             ({-# LINE 458 "Order.ag" #-}
                              _lhsIallTypeSigs
                              {-# LINE 2193 "Order.hs" #-})
                         -- copy rule (down)
                         _partsOaltAttrs =
                             ({-# LINE 166 "Order.ag" #-}
                              _lhsIaltAttrs
                              {-# LINE 2198 "Order.hs" #-})
                         -- copy rule (down)
                         _partsOcon =
                             ({-# LINE 70 "Order.ag" #-}
                              _lhsIcon
                              {-# LINE 2203 "Order.hs" #-})
                         -- copy rule (down)
                         _partsOinh =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIinh
                              {-# LINE 2208 "Order.hs" #-})
                         -- copy rule (down)
                         _partsOnt =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsInt
                              {-# LINE 2213 "Order.hs" #-})
                         -- copy rule (down)
                         _partsOsyn =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIsyn
                              {-# LINE 2218 "Order.hs" #-})
                         ( _patIcopy,_patIerrors,_patIgathAltAttrs,_patIinstVars,_patIlocVars,_patIpatternAttrs) =
                             (pat_ _patOallTypeSigs _patOaltAttrs _patOcon _patOinh _patOnt _patOsyn )
                         ( _partsIcopy,_partsIerrors,_partsIgathAltAttrs,_partsIinstVars,_partsIlocVars,_partsIpatternAttrs) =
                             (parts_ _partsOallTypeSigs _partsOaltAttrs _partsOcon _partsOinh _partsOnt _partsOsyn )
                     in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
sem_Pattern_Constr :: ConstructorIdent ->
                      T_Patterns  ->
                      T_Pattern 
sem_Pattern_Constr name_ (T_Patterns pats_ )  =
    (T_Pattern (\ _lhsIallTypeSigs
                  _lhsIaltAttrs
                  _lhsIcon
                  _lhsIinh
                  _lhsInt
                  _lhsIsyn ->
                    (let _lhsOerrors :: (Seq Error)
                         _lhsOgathAltAttrs :: ([AltAttr])
                         _lhsOinstVars :: ([Identifier])
                         _lhsOlocVars :: ([Identifier])
                         _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         _lhsOcopy :: Pattern 
                         _patsOallTypeSigs :: (Map Identifier Type)
                         _patsOaltAttrs :: (Map AltAttr Vertex)
                         _patsOcon :: Identifier
                         _patsOinh :: Attributes
                         _patsOnt :: Identifier
                         _patsOsyn :: Attributes
                         _patsIcopy :: Patterns 
                         _patsIerrors :: (Seq Error)
                         _patsIgathAltAttrs :: ([AltAttr])
                         _patsIinstVars :: ([Identifier])
                         _patsIlocVars :: ([Identifier])
                         _patsIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         -- use rule "Order.ag"(line 64, column 70)
                         _lhsOerrors =
                             ({-# LINE 64 "Order.ag" #-}
                              _patsIerrors
                              {-# LINE 2256 "Order.hs" #-})
                         -- use rule "Order.ag"(line 150, column 68)
                         _lhsOgathAltAttrs =
                             ({-# LINE 150 "Order.ag" #-}
                              _patsIgathAltAttrs
                              {-# LINE 2261 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 86)
                         _lhsOinstVars =
                             ({-# LINE 600 "Order.ag" #-}
                              _patsIinstVars
                              {-# LINE 2266 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 48)
                         _lhsOlocVars =
                             ({-# LINE 600 "Order.ag" #-}
                              _patsIlocVars
                              {-# LINE 2271 "Order.hs" #-})
                         -- use rule "Order.ag"(line 229, column 42)
                         _lhsOpatternAttrs =
                             ({-# LINE 229 "Order.ag" #-}
                              _patsIpatternAttrs
                              {-# LINE 2276 "Order.hs" #-})
                         -- self rule
                         _copy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              Constr name_ _patsIcopy
                              {-# LINE 2281 "Order.hs" #-})
                         -- self rule
                         _lhsOcopy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              _copy
                              {-# LINE 2286 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOallTypeSigs =
                             ({-# LINE 458 "Order.ag" #-}
                              _lhsIallTypeSigs
                              {-# LINE 2291 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOaltAttrs =
                             ({-# LINE 166 "Order.ag" #-}
                              _lhsIaltAttrs
                              {-# LINE 2296 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOcon =
                             ({-# LINE 70 "Order.ag" #-}
                              _lhsIcon
                              {-# LINE 2301 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOinh =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIinh
                              {-# LINE 2306 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOnt =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsInt
                              {-# LINE 2311 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOsyn =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIsyn
                              {-# LINE 2316 "Order.hs" #-})
                         ( _patsIcopy,_patsIerrors,_patsIgathAltAttrs,_patsIinstVars,_patsIlocVars,_patsIpatternAttrs) =
                             (pats_ _patsOallTypeSigs _patsOaltAttrs _patsOcon _patsOinh _patsOnt _patsOsyn )
                     in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
sem_Pattern_Irrefutable :: T_Pattern  ->
                           T_Pattern 
sem_Pattern_Irrefutable (T_Pattern pat_ )  =
    (T_Pattern (\ _lhsIallTypeSigs
                  _lhsIaltAttrs
                  _lhsIcon
                  _lhsIinh
                  _lhsInt
                  _lhsIsyn ->
                    (let _lhsOerrors :: (Seq Error)
                         _lhsOgathAltAttrs :: ([AltAttr])
                         _lhsOinstVars :: ([Identifier])
                         _lhsOlocVars :: ([Identifier])
                         _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         _lhsOcopy :: Pattern 
                         _patOallTypeSigs :: (Map Identifier Type)
                         _patOaltAttrs :: (Map AltAttr Vertex)
                         _patOcon :: Identifier
                         _patOinh :: Attributes
                         _patOnt :: Identifier
                         _patOsyn :: Attributes
                         _patIcopy :: Pattern 
                         _patIerrors :: (Seq Error)
                         _patIgathAltAttrs :: ([AltAttr])
                         _patIinstVars :: ([Identifier])
                         _patIlocVars :: ([Identifier])
                         _patIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         -- use rule "Order.ag"(line 64, column 70)
                         _lhsOerrors =
                             ({-# LINE 64 "Order.ag" #-}
                              _patIerrors
                              {-# LINE 2351 "Order.hs" #-})
                         -- use rule "Order.ag"(line 150, column 68)
                         _lhsOgathAltAttrs =
                             ({-# LINE 150 "Order.ag" #-}
                              _patIgathAltAttrs
                              {-# LINE 2356 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 86)
                         _lhsOinstVars =
                             ({-# LINE 600 "Order.ag" #-}
                              _patIinstVars
                              {-# LINE 2361 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 48)
                         _lhsOlocVars =
                             ({-# LINE 600 "Order.ag" #-}
                              _patIlocVars
                              {-# LINE 2366 "Order.hs" #-})
                         -- use rule "Order.ag"(line 229, column 42)
                         _lhsOpatternAttrs =
                             ({-# LINE 229 "Order.ag" #-}
                              _patIpatternAttrs
                              {-# LINE 2371 "Order.hs" #-})
                         -- self rule
                         _copy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              Irrefutable _patIcopy
                              {-# LINE 2376 "Order.hs" #-})
                         -- self rule
                         _lhsOcopy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              _copy
                              {-# LINE 2381 "Order.hs" #-})
                         -- copy rule (down)
                         _patOallTypeSigs =
                             ({-# LINE 458 "Order.ag" #-}
                              _lhsIallTypeSigs
                              {-# LINE 2386 "Order.hs" #-})
                         -- copy rule (down)
                         _patOaltAttrs =
                             ({-# LINE 166 "Order.ag" #-}
                              _lhsIaltAttrs
                              {-# LINE 2391 "Order.hs" #-})
                         -- copy rule (down)
                         _patOcon =
                             ({-# LINE 70 "Order.ag" #-}
                              _lhsIcon
                              {-# LINE 2396 "Order.hs" #-})
                         -- copy rule (down)
                         _patOinh =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIinh
                              {-# LINE 2401 "Order.hs" #-})
                         -- copy rule (down)
                         _patOnt =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsInt
                              {-# LINE 2406 "Order.hs" #-})
                         -- copy rule (down)
                         _patOsyn =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIsyn
                              {-# LINE 2411 "Order.hs" #-})
                         ( _patIcopy,_patIerrors,_patIgathAltAttrs,_patIinstVars,_patIlocVars,_patIpatternAttrs) =
                             (pat_ _patOallTypeSigs _patOaltAttrs _patOcon _patOinh _patOnt _patOsyn )
                     in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
sem_Pattern_Product :: Pos ->
                       T_Patterns  ->
                       T_Pattern 
sem_Pattern_Product pos_ (T_Patterns pats_ )  =
    (T_Pattern (\ _lhsIallTypeSigs
                  _lhsIaltAttrs
                  _lhsIcon
                  _lhsIinh
                  _lhsInt
                  _lhsIsyn ->
                    (let _lhsOerrors :: (Seq Error)
                         _lhsOgathAltAttrs :: ([AltAttr])
                         _lhsOinstVars :: ([Identifier])
                         _lhsOlocVars :: ([Identifier])
                         _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         _lhsOcopy :: Pattern 
                         _patsOallTypeSigs :: (Map Identifier Type)
                         _patsOaltAttrs :: (Map AltAttr Vertex)
                         _patsOcon :: Identifier
                         _patsOinh :: Attributes
                         _patsOnt :: Identifier
                         _patsOsyn :: Attributes
                         _patsIcopy :: Patterns 
                         _patsIerrors :: (Seq Error)
                         _patsIgathAltAttrs :: ([AltAttr])
                         _patsIinstVars :: ([Identifier])
                         _patsIlocVars :: ([Identifier])
                         _patsIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         -- use rule "Order.ag"(line 64, column 70)
                         _lhsOerrors =
                             ({-# LINE 64 "Order.ag" #-}
                              _patsIerrors
                              {-# LINE 2447 "Order.hs" #-})
                         -- use rule "Order.ag"(line 150, column 68)
                         _lhsOgathAltAttrs =
                             ({-# LINE 150 "Order.ag" #-}
                              _patsIgathAltAttrs
                              {-# LINE 2452 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 86)
                         _lhsOinstVars =
                             ({-# LINE 600 "Order.ag" #-}
                              _patsIinstVars
                              {-# LINE 2457 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 48)
                         _lhsOlocVars =
                             ({-# LINE 600 "Order.ag" #-}
                              _patsIlocVars
                              {-# LINE 2462 "Order.hs" #-})
                         -- use rule "Order.ag"(line 229, column 42)
                         _lhsOpatternAttrs =
                             ({-# LINE 229 "Order.ag" #-}
                              _patsIpatternAttrs
                              {-# LINE 2467 "Order.hs" #-})
                         -- self rule
                         _copy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              Product pos_ _patsIcopy
                              {-# LINE 2472 "Order.hs" #-})
                         -- self rule
                         _lhsOcopy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              _copy
                              {-# LINE 2477 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOallTypeSigs =
                             ({-# LINE 458 "Order.ag" #-}
                              _lhsIallTypeSigs
                              {-# LINE 2482 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOaltAttrs =
                             ({-# LINE 166 "Order.ag" #-}
                              _lhsIaltAttrs
                              {-# LINE 2487 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOcon =
                             ({-# LINE 70 "Order.ag" #-}
                              _lhsIcon
                              {-# LINE 2492 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOinh =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIinh
                              {-# LINE 2497 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOnt =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsInt
                              {-# LINE 2502 "Order.hs" #-})
                         -- copy rule (down)
                         _patsOsyn =
                             ({-# LINE 69 "Order.ag" #-}
                              _lhsIsyn
                              {-# LINE 2507 "Order.hs" #-})
                         ( _patsIcopy,_patsIerrors,_patsIgathAltAttrs,_patsIinstVars,_patsIlocVars,_patsIpatternAttrs) =
                             (pats_ _patsOallTypeSigs _patsOaltAttrs _patsOcon _patsOinh _patsOnt _patsOsyn )
                     in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
sem_Pattern_Underscore :: Pos ->
                          T_Pattern 
sem_Pattern_Underscore pos_  =
    (T_Pattern (\ _lhsIallTypeSigs
                  _lhsIaltAttrs
                  _lhsIcon
                  _lhsIinh
                  _lhsInt
                  _lhsIsyn ->
                    (let _lhsOerrors :: (Seq Error)
                         _lhsOgathAltAttrs :: ([AltAttr])
                         _lhsOinstVars :: ([Identifier])
                         _lhsOlocVars :: ([Identifier])
                         _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                         _lhsOcopy :: Pattern 
                         -- use rule "Order.ag"(line 64, column 70)
                         _lhsOerrors =
                             ({-# LINE 64 "Order.ag" #-}
                              Seq.empty
                              {-# LINE 2530 "Order.hs" #-})
                         -- use rule "Order.ag"(line 150, column 68)
                         _lhsOgathAltAttrs =
                             ({-# LINE 150 "Order.ag" #-}
                              []
                              {-# LINE 2535 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 86)
                         _lhsOinstVars =
                             ({-# LINE 600 "Order.ag" #-}
                              []
                              {-# LINE 2540 "Order.hs" #-})
                         -- use rule "Order.ag"(line 600, column 48)
                         _lhsOlocVars =
                             ({-# LINE 600 "Order.ag" #-}
                              []
                              {-# LINE 2545 "Order.hs" #-})
                         -- use rule "Order.ag"(line 229, column 42)
                         _lhsOpatternAttrs =
                             ({-# LINE 229 "Order.ag" #-}
                              []
                              {-# LINE 2550 "Order.hs" #-})
                         -- self rule
                         _copy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              Underscore pos_
                              {-# LINE 2555 "Order.hs" #-})
                         -- self rule
                         _lhsOcopy =
                             ({-# LINE 23 "./Patterns.ag" #-}
                              _copy
                              {-# LINE 2560 "Order.hs" #-})
                     in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
-- Patterns ----------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allTypeSigs          : Map Identifier Type
         altAttrs             : Map AltAttr Vertex
         con                  : Identifier
         inh                  : Attributes
         nt                   : Identifier
         syn                  : Attributes
      synthesized attributes:
         copy                 : SELF 
         errors               : Seq Error
         gathAltAttrs         : [AltAttr]
         instVars             : [Identifier]
         locVars              : [Identifier]
         patternAttrs         : [(Identifier,Identifier,Bool,Patterns)]
   alternatives:
      alternative Cons:
         child hd             : Pattern 
         child tl             : Patterns 
         visit 0:
            local copy        : _
      alternative Nil:
         visit 0:
            local copy        : _
-}
-- cata
sem_Patterns :: Patterns  ->
                T_Patterns 
sem_Patterns list  =
    (Prelude.foldr sem_Patterns_Cons sem_Patterns_Nil (Prelude.map sem_Pattern list) )
-- semantic domain
newtype T_Patterns  = T_Patterns ((Map Identifier Type) ->
                                  (Map AltAttr Vertex) ->
                                  Identifier ->
                                  Attributes ->
                                  Identifier ->
                                  Attributes ->
                                  ( Patterns ,(Seq Error),([AltAttr]),([Identifier]),([Identifier]),([(Identifier,Identifier,Bool,Patterns)])))
data Inh_Patterns  = Inh_Patterns {allTypeSigs_Inh_Patterns :: !((Map Identifier Type)),altAttrs_Inh_Patterns :: !((Map AltAttr Vertex)),con_Inh_Patterns :: !(Identifier),inh_Inh_Patterns :: !(Attributes),nt_Inh_Patterns :: !(Identifier),syn_Inh_Patterns :: !(Attributes)}
data Syn_Patterns  = Syn_Patterns {copy_Syn_Patterns :: !(Patterns ),errors_Syn_Patterns :: !((Seq Error)),gathAltAttrs_Syn_Patterns :: !(([AltAttr])),instVars_Syn_Patterns :: !(([Identifier])),locVars_Syn_Patterns :: !(([Identifier])),patternAttrs_Syn_Patterns :: !(([(Identifier,Identifier,Bool,Patterns)]))}
wrap_Patterns :: T_Patterns  ->
                 Inh_Patterns  ->
                 Syn_Patterns 
wrap_Patterns (T_Patterns sem ) (Inh_Patterns _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn )  =
    (let ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs) =
             (sem _lhsIallTypeSigs _lhsIaltAttrs _lhsIcon _lhsIinh _lhsInt _lhsIsyn )
     in  (Syn_Patterns _lhsOcopy _lhsOerrors _lhsOgathAltAttrs _lhsOinstVars _lhsOlocVars _lhsOpatternAttrs ))
sem_Patterns_Cons :: T_Pattern  ->
                     T_Patterns  ->
                     T_Patterns 
sem_Patterns_Cons (T_Pattern hd_ ) (T_Patterns tl_ )  =
    (T_Patterns (\ _lhsIallTypeSigs
                   _lhsIaltAttrs
                   _lhsIcon
                   _lhsIinh
                   _lhsInt
                   _lhsIsyn ->
                     (let _lhsOerrors :: (Seq Error)
                          _lhsOgathAltAttrs :: ([AltAttr])
                          _lhsOinstVars :: ([Identifier])
                          _lhsOlocVars :: ([Identifier])
                          _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                          _lhsOcopy :: Patterns 
                          _hdOallTypeSigs :: (Map Identifier Type)
                          _hdOaltAttrs :: (Map AltAttr Vertex)
                          _hdOcon :: Identifier
                          _hdOinh :: Attributes
                          _hdOnt :: Identifier
                          _hdOsyn :: Attributes
                          _tlOallTypeSigs :: (Map Identifier Type)
                          _tlOaltAttrs :: (Map AltAttr Vertex)
                          _tlOcon :: Identifier
                          _tlOinh :: Attributes
                          _tlOnt :: Identifier
                          _tlOsyn :: Attributes
                          _hdIcopy :: Pattern 
                          _hdIerrors :: (Seq Error)
                          _hdIgathAltAttrs :: ([AltAttr])
                          _hdIinstVars :: ([Identifier])
                          _hdIlocVars :: ([Identifier])
                          _hdIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                          _tlIcopy :: Patterns 
                          _tlIerrors :: (Seq Error)
                          _tlIgathAltAttrs :: ([AltAttr])
                          _tlIinstVars :: ([Identifier])
                          _tlIlocVars :: ([Identifier])
                          _tlIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                          -- use rule "Order.ag"(line 64, column 70)
                          _lhsOerrors =
                              ({-# LINE 64 "Order.ag" #-}
                               _hdIerrors Seq.>< _tlIerrors
                               {-# LINE 2655 "Order.hs" #-})
                          -- use rule "Order.ag"(line 150, column 68)
                          _lhsOgathAltAttrs =
                              ({-# LINE 150 "Order.ag" #-}
                               _hdIgathAltAttrs ++ _tlIgathAltAttrs
                               {-# LINE 2660 "Order.hs" #-})
                          -- use rule "Order.ag"(line 600, column 86)
                          _lhsOinstVars =
                              ({-# LINE 600 "Order.ag" #-}
                               _hdIinstVars ++ _tlIinstVars
                               {-# LINE 2665 "Order.hs" #-})
                          -- use rule "Order.ag"(line 600, column 48)
                          _lhsOlocVars =
                              ({-# LINE 600 "Order.ag" #-}
                               _hdIlocVars ++ _tlIlocVars
                               {-# LINE 2670 "Order.hs" #-})
                          -- use rule "Order.ag"(line 229, column 42)
                          _lhsOpatternAttrs =
                              ({-# LINE 229 "Order.ag" #-}
                               _hdIpatternAttrs ++ _tlIpatternAttrs
                               {-# LINE 2675 "Order.hs" #-})
                          -- self rule
                          _copy =
                              ({-# LINE 23 "./Patterns.ag" #-}
                               (:) _hdIcopy _tlIcopy
                               {-# LINE 2680 "Order.hs" #-})
                          -- self rule
                          _lhsOcopy =
                              ({-# LINE 23 "./Patterns.ag" #-}
                               _copy
                               {-# LINE 2685 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOallTypeSigs =
                              ({-# LINE 458 "Order.ag" #-}
                               _lhsIallTypeSigs
                               {-# LINE 2690 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOaltAttrs =
                              ({-# LINE 166 "Order.ag" #-}
                               _lhsIaltAttrs
                               {-# LINE 2695 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOcon =
                              ({-# LINE 70 "Order.ag" #-}
                               _lhsIcon
                               {-# LINE 2700 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOinh =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIinh
                               {-# LINE 2705 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOnt =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsInt
                               {-# LINE 2710 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOsyn =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIsyn
                               {-# LINE 2715 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOallTypeSigs =
                              ({-# LINE 458 "Order.ag" #-}
                               _lhsIallTypeSigs
                               {-# LINE 2720 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOaltAttrs =
                              ({-# LINE 166 "Order.ag" #-}
                               _lhsIaltAttrs
                               {-# LINE 2725 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOcon =
                              ({-# LINE 70 "Order.ag" #-}
                               _lhsIcon
                               {-# LINE 2730 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOinh =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIinh
                               {-# LINE 2735 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOnt =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsInt
                               {-# LINE 2740 "Order.hs" #-})
                          -- copy rule (down)
                          _tlOsyn =
                              ({-# LINE 69 "Order.ag" #-}
                               _lhsIsyn
                               {-# LINE 2745 "Order.hs" #-})
                          ( _hdIcopy,_hdIerrors,_hdIgathAltAttrs,_hdIinstVars,_hdIlocVars,_hdIpatternAttrs) =
                              (hd_ _hdOallTypeSigs _hdOaltAttrs _hdOcon _hdOinh _hdOnt _hdOsyn )
                          ( _tlIcopy,_tlIerrors,_tlIgathAltAttrs,_tlIinstVars,_tlIlocVars,_tlIpatternAttrs) =
                              (tl_ _tlOallTypeSigs _tlOaltAttrs _tlOcon _tlOinh _tlOnt _tlOsyn )
                      in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
sem_Patterns_Nil :: T_Patterns 
sem_Patterns_Nil  =
    (T_Patterns (\ _lhsIallTypeSigs
                   _lhsIaltAttrs
                   _lhsIcon
                   _lhsIinh
                   _lhsInt
                   _lhsIsyn ->
                     (let _lhsOerrors :: (Seq Error)
                          _lhsOgathAltAttrs :: ([AltAttr])
                          _lhsOinstVars :: ([Identifier])
                          _lhsOlocVars :: ([Identifier])
                          _lhsOpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                          _lhsOcopy :: Patterns 
                          -- use rule "Order.ag"(line 64, column 70)
                          _lhsOerrors =
                              ({-# LINE 64 "Order.ag" #-}
                               Seq.empty
                               {-# LINE 2769 "Order.hs" #-})
                          -- use rule "Order.ag"(line 150, column 68)
                          _lhsOgathAltAttrs =
                              ({-# LINE 150 "Order.ag" #-}
                               []
                               {-# LINE 2774 "Order.hs" #-})
                          -- use rule "Order.ag"(line 600, column 86)
                          _lhsOinstVars =
                              ({-# LINE 600 "Order.ag" #-}
                               []
                               {-# LINE 2779 "Order.hs" #-})
                          -- use rule "Order.ag"(line 600, column 48)
                          _lhsOlocVars =
                              ({-# LINE 600 "Order.ag" #-}
                               []
                               {-# LINE 2784 "Order.hs" #-})
                          -- use rule "Order.ag"(line 229, column 42)
                          _lhsOpatternAttrs =
                              ({-# LINE 229 "Order.ag" #-}
                               []
                               {-# LINE 2789 "Order.hs" #-})
                          -- self rule
                          _copy =
                              ({-# LINE 23 "./Patterns.ag" #-}
                               []
                               {-# LINE 2794 "Order.hs" #-})
                          -- self rule
                          _lhsOcopy =
                              ({-# LINE 23 "./Patterns.ag" #-}
                               _copy
                               {-# LINE 2799 "Order.hs" #-})
                      in  ( _lhsOcopy,_lhsOerrors,_lhsOgathAltAttrs,_lhsOinstVars,_lhsOlocVars,_lhsOpatternAttrs))) )
-- Production --------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allnts               : [Identifier]
         aroundMap            : Map ConstructorIdent (Map Identifier [Expression])
         cVisitsMap           : CVisitsMap
         inh                  : Attributes
         manualAttrDepMap     : AttrOrderMap
         nt                   : Identifier
         o_case               : Bool
         o_cata               : Bool
         o_dovisit            : Bool
         o_newtypes           : Bool
         o_rename             : Bool
         o_sem                : Bool
         o_sig                : Bool
         o_unbox              : Bool
         o_wantvisit          : Bool
         prefix               : String
         syn                  : Attributes
      chained attribute:
         vcount               : Int
      synthesized attributes:
         additionalDep        : Seq Edge
         aroundDep            : Seq Edge
         cProduction          : CProduction
         cons                 : [ConstructorIdent]
         directDep            : Seq Edge
         errors               : Seq Error
         instDep              : Seq Edge
         rules                : Seq (Vertex,CRule)
   alternatives:
      alternative Production:
         child con            : {ConstructorIdent}
         child children       : Children 
         child rules          : Rules 
         child typeSigs       : TypeSigs 
         visit 0:
            local gathAltAttrs : _
            local altAttrs    : _
            local inhRules    : _
            local gathRules   : _
            local manualDeps  : _
            local aroundMap   : _
            local aroundDep1  : _
            local aroundDep2  : _
            local cVisits     : _
            local allfields   : _
            local attrs       : _
            local inhnames    : _
            local synnames    : _
-}
-- cata
sem_Production :: Production  ->
                  T_Production 
sem_Production (Production _con _children _rules _typeSigs )  =
    (sem_Production_Production _con (sem_Children _children ) (sem_Rules _rules ) (sem_TypeSigs _typeSigs ) )
-- semantic domain
newtype T_Production  = T_Production (([Identifier]) ->
                                      (Map ConstructorIdent (Map Identifier [Expression])) ->
                                      CVisitsMap ->
                                      Attributes ->
                                      AttrOrderMap ->
                                      Identifier ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      Bool ->
                                      String ->
                                      Attributes ->
                                      Int ->
                                      ( (Seq Edge),(Seq Edge),CProduction,([ConstructorIdent]),(Seq Edge),(Seq Error),(Seq Edge),(Seq (Vertex,CRule)),Int))
data Inh_Production  = Inh_Production {allnts_Inh_Production :: !(([Identifier])),aroundMap_Inh_Production :: !((Map ConstructorIdent (Map Identifier [Expression]))),cVisitsMap_Inh_Production :: !(CVisitsMap),inh_Inh_Production :: !(Attributes),manualAttrDepMap_Inh_Production :: !(AttrOrderMap),nt_Inh_Production :: !(Identifier),o_case_Inh_Production :: !(Bool),o_cata_Inh_Production :: !(Bool),o_dovisit_Inh_Production :: !(Bool),o_newtypes_Inh_Production :: !(Bool),o_rename_Inh_Production :: !(Bool),o_sem_Inh_Production :: !(Bool),o_sig_Inh_Production :: !(Bool),o_unbox_Inh_Production :: !(Bool),o_wantvisit_Inh_Production :: !(Bool),prefix_Inh_Production :: !(String),syn_Inh_Production :: !(Attributes),vcount_Inh_Production :: !(Int)}
data Syn_Production  = Syn_Production {additionalDep_Syn_Production :: !((Seq Edge)),aroundDep_Syn_Production :: !((Seq Edge)),cProduction_Syn_Production :: !(CProduction),cons_Syn_Production :: !(([ConstructorIdent])),directDep_Syn_Production :: !((Seq Edge)),errors_Syn_Production :: !((Seq Error)),instDep_Syn_Production :: !((Seq Edge)),rules_Syn_Production :: !((Seq (Vertex,CRule))),vcount_Syn_Production :: !(Int)}
wrap_Production :: T_Production  ->
                   Inh_Production  ->
                   Syn_Production 
wrap_Production (T_Production sem ) (Inh_Production _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount )  =
    (let ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProduction,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount) =
             (sem _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount )
     in  (Syn_Production _lhsOadditionalDep _lhsOaroundDep _lhsOcProduction _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOrules _lhsOvcount ))
sem_Production_Production :: ConstructorIdent ->
                             T_Children  ->
                             T_Rules  ->
                             T_TypeSigs  ->
                             T_Production 
sem_Production_Production con_ (T_Children children_ ) (T_Rules rules_ ) (T_TypeSigs typeSigs_ )  =
    (T_Production (\ _lhsIallnts
                     _lhsIaroundMap
                     _lhsIcVisitsMap
                     _lhsIinh
                     _lhsImanualAttrDepMap
                     _lhsInt
                     _lhsIo_case
                     _lhsIo_cata
                     _lhsIo_dovisit
                     _lhsIo_newtypes
                     _lhsIo_rename
                     _lhsIo_sem
                     _lhsIo_sig
                     _lhsIo_unbox
                     _lhsIo_wantvisit
                     _lhsIprefix
                     _lhsIsyn
                     _lhsIvcount ->
                       (let _childrenOcon :: Identifier
                            _rulesOcon :: Identifier
                            _rulesOchildNts :: (Map Identifier NontermIdent)
                            _rulesOchildInhs :: (Map Identifier Attributes)
                            _lhsOrules :: (Seq (Vertex,CRule))
                            _lhsOvcount :: Int
                            _lhsOadditionalDep :: (Seq Edge)
                            _rulesOsynsOfChildren :: (Map Identifier Attributes)
                            _rulesOinhsOfChildren :: (Map Identifier Attributes)
                            _lhsOaroundDep :: (Seq Edge)
                            _lhsOcons :: ([ConstructorIdent])
                            _typeSigsOtypeSigs :: (Map Identifier Type)
                            _rulesOallTypeSigs :: (Map Identifier Type)
                            _lhsOcProduction :: CProduction
                            _lhsOdirectDep :: (Seq Edge)
                            _lhsOerrors :: (Seq Error)
                            _lhsOinstDep :: (Seq Edge)
                            _childrenOallfields :: ([(Identifier,Type,Bool)])
                            _childrenOallnts :: ([Identifier])
                            _childrenOattrs :: ([(Identifier,Identifier)])
                            _childrenOinh :: Attributes
                            _childrenOnt :: Identifier
                            _childrenOo_unbox :: Bool
                            _childrenOsyn :: Attributes
                            _rulesOallfields :: ([(Identifier,Type,Bool)])
                            _rulesOallnts :: ([Identifier])
                            _rulesOaltAttrs :: (Map AltAttr Vertex)
                            _rulesOattrs :: ([(Identifier,Identifier)])
                            _rulesOinh :: Attributes
                            _rulesOnt :: Identifier
                            _rulesOo_case :: Bool
                            _rulesOo_cata :: Bool
                            _rulesOo_dovisit :: Bool
                            _rulesOo_newtypes :: Bool
                            _rulesOo_rename :: Bool
                            _rulesOo_sem :: Bool
                            _rulesOo_sig :: Bool
                            _rulesOo_wantvisit :: Bool
                            _rulesOprefix :: String
                            _rulesOsyn :: Attributes
                            _childrenIattributes :: ([(Identifier,Attributes,Attributes)])
                            _childrenIcollectChildrenInhs :: (Map Identifier Attributes )
                            _childrenIcollectChildrenSyns :: (Map Identifier Attributes )
                            _childrenIerrors :: (Seq Error)
                            _childrenIfields :: ([(Identifier,Type,Bool)])
                            _childrenIgathAltAttrs :: ([AltAttr])
                            _childrenIgathRules :: (Seq CRule)
                            _childrenIinhs :: (Seq (Identifier,Attributes))
                            _childrenInts :: (Seq (Identifier,NontermIdent))
                            _childrenIsinglevisits :: ([CRule])
                            _childrenIterminals :: ([Identifier])
                            _rulesIdirectDep :: (Seq Edge)
                            _rulesIerrors :: (Seq Error)
                            _rulesIgathAltAttrs :: ([AltAttr])
                            _rulesIgathRules :: (Seq CRule)
                            _rulesIinstDep :: (Seq Edge)
                            _rulesIinstVars :: ([Identifier])
                            _rulesIlocVars :: ([Identifier])
                            _typeSigsItypeSigs :: (Map Identifier Type)
                            -- "Order.ag"(line 73, column 16)
                            _childrenOcon =
                                ({-# LINE 73 "Order.ag" #-}
                                 con_
                                 {-# LINE 2975 "Order.hs" #-})
                            -- "Order.ag"(line 75, column 16)
                            _rulesOcon =
                                ({-# LINE 75 "Order.ag" #-}
                                 con_
                                 {-# LINE 2980 "Order.hs" #-})
                            -- "Order.ag"(line 152, column 18)
                            _gathAltAttrs =
                                ({-# LINE 152 "Order.ag" #-}
                                 [ AltAttr _LHS inh True | inh <- Map.keys _lhsIinh ]
                                  ++ _childrenIgathAltAttrs
                                  ++ _rulesIgathAltAttrs
                                 {-# LINE 2987 "Order.hs" #-})
                            -- "Order.ag"(line 168, column 17)
                            _altAttrs =
                                ({-# LINE 168 "Order.ag" #-}
                                 Map.fromList (zip _gathAltAttrs [_lhsIvcount..])
                                 {-# LINE 2992 "Order.hs" #-})
                            -- "Order.ag"(line 181, column 18)
                            _rulesOchildNts =
                                ({-# LINE 181 "Order.ag" #-}
                                 Map.fromList (toList _childrenInts)
                                 {-# LINE 2997 "Order.hs" #-})
                            -- "Order.ag"(line 182, column 19)
                            _rulesOchildInhs =
                                ({-# LINE 182 "Order.ag" #-}
                                 Map.fromList (toList _childrenIinhs)
                                 {-# LINE 3002 "Order.hs" #-})
                            -- "Order.ag"(line 188, column 18)
                            _inhRules =
                                ({-# LINE 188 "Order.ag" #-}
                                 [ cRuleLhsInh inh _lhsInt con_ tp | (inh,tp) <- Map.assocs _lhsIinh ]
                                 {-# LINE 3007 "Order.hs" #-})
                            -- "Order.ag"(line 189, column 19)
                            _gathRules =
                                ({-# LINE 189 "Order.ag" #-}
                                 _inhRules ++ toList (_childrenIgathRules Seq.>< _rulesIgathRules)
                                 {-# LINE 3012 "Order.hs" #-})
                            -- "Order.ag"(line 243, column 18)
                            _lhsOrules =
                                ({-# LINE 243 "Order.ag" #-}
                                 Seq.fromList (zip [_lhsIvcount..] _gathRules)
                                 {-# LINE 3017 "Order.hs" #-})
                            -- "Order.ag"(line 244, column 19)
                            _lhsOvcount =
                                ({-# LINE 244 "Order.ag" #-}
                                 _lhsIvcount + length _gathRules
                                 {-# LINE 3022 "Order.hs" #-})
                            -- "Order.ag"(line 271, column 7)
                            _manualDeps =
                                ({-# LINE 271 "Order.ag" #-}
                                 Set.toList $ Map.findWithDefault Set.empty con_ $ Map.findWithDefault Map.empty _lhsInt _lhsImanualAttrDepMap
                                 {-# LINE 3027 "Order.hs" #-})
                            -- "Order.ag"(line 274, column 7)
                            _lhsOadditionalDep =
                                ({-# LINE 274 "Order.ag" #-}
                                 Seq.fromList [ (vertex True occA, vertex False occB)
                                              | Dependency occA occB <- _manualDeps
                                              , let vertex inout (OccAttr child nm)
                                                      | child == _LOC = findWithErr2 (AltAttr _LOC nm True) _altAttrs
                                                      | otherwise     = findWithErr2 (AltAttr child nm inout) _altAttrs
                                                    vertex _ (OccRule nm)
                                                      = findWithErr2 (AltAttr _LOC (Ident ("_rule_" ++ show nm) (getPos nm)) True) _altAttrs
                                              ]
                                 {-# LINE 3039 "Order.hs" #-})
                            -- "Order.ag"(line 321, column 17)
                            _rulesOsynsOfChildren =
                                ({-# LINE 321 "Order.ag" #-}
                                 _childrenIcollectChildrenSyns
                                 {-# LINE 3044 "Order.hs" #-})
                            -- "Order.ag"(line 322, column 17)
                            _rulesOinhsOfChildren =
                                ({-# LINE 322 "Order.ag" #-}
                                 _childrenIcollectChildrenInhs
                                 {-# LINE 3049 "Order.hs" #-})
                            -- "Order.ag"(line 347, column 32)
                            _aroundMap =
                                ({-# LINE 347 "Order.ag" #-}
                                 Map.findWithDefault Map.empty con_ _lhsIaroundMap
                                 {-# LINE 3054 "Order.hs" #-})
                            -- "Order.ag"(line 354, column 6)
                            _aroundDep1 =
                                ({-# LINE 354 "Order.ag" #-}
                                 Seq.fromList $
                                   [ (childVert, synVert)
                                   | childNm <- Map.keys _aroundMap
                                   , synNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenSyns)
                                   , let childNm' = Ident (show childNm ++ "_around") (getPos childNm)
                                         childAttr = AltAttr _LOC childNm' True
                                         synAttr  = AltAttr childNm synNm True
                                         childVert = findWithErr2 childAttr _altAttrs
                                         synVert  = findWithErr2 synAttr _altAttrs
                                   ]
                                 {-# LINE 3068 "Order.hs" #-})
                            -- "Order.ag"(line 365, column 6)
                            _aroundDep2 =
                                ({-# LINE 365 "Order.ag" #-}
                                 Seq.fromList $
                                   [ (childVert, inhVert)
                                   | childNm <- Map.keys _aroundMap
                                   , inhNm <- Map.keys (findWithErr2 childNm _childrenIcollectChildrenInhs)
                                   , let childNm'  = Ident (show childNm ++ "_around") (getPos childNm)
                                         childAttr = AltAttr _LOC childNm' True
                                         inhAttr   = AltAttr childNm inhNm False
                                         childVert = findWithErr2 childAttr _altAttrs
                                         inhVert   = findWithErr2 inhAttr _altAttrs
                                   ]
                                 {-# LINE 3082 "Order.hs" #-})
                            -- "Order.ag"(line 376, column 6)
                            _lhsOaroundDep =
                                ({-# LINE 376 "Order.ag" #-}
                                 _aroundDep1     Seq.>< _aroundDep2
                                 {-# LINE 3087 "Order.hs" #-})
                            -- "Order.ag"(line 447, column 18)
                            _lhsOcons =
                                ({-# LINE 447 "Order.ag" #-}
                                 [con_]
                                 {-# LINE 3092 "Order.hs" #-})
                            -- "Order.ag"(line 454, column 16)
                            _typeSigsOtypeSigs =
                                ({-# LINE 454 "Order.ag" #-}
                                 Map.empty
                                 {-# LINE 3097 "Order.hs" #-})
                            -- "Order.ag"(line 460, column 17)
                            _rulesOallTypeSigs =
                                ({-# LINE 460 "Order.ag" #-}
                                 _typeSigsItypeSigs
                                 {-# LINE 3102 "Order.hs" #-})
                            -- "Order.ag"(line 527, column 17)
                            _cVisits =
                                ({-# LINE 527 "Order.ag" #-}
                                 if  _lhsIo_dovisit
                                      then let prodsVisitsMap = findWithErr1 "Production.cVisits.nt" _lhsInt _lhsIcVisitsMap
                                               visits = findWithErr1 "Production.cVisits.con" con_ prodsVisitsMap
                                            in visits
                                      else  let  vss = nubBy eqCRuleDefines _gathRules ++ _childrenIsinglevisits
                                            in  [CVisit _lhsIinh _lhsIsyn vss [] False]
                                 {-# LINE 3112 "Order.hs" #-})
                            -- "Order.ag"(line 553, column 18)
                            _lhsOcProduction =
                                ({-# LINE 553 "Order.ag" #-}
                                 CProduction con_ _cVisits _childrenIfields _childrenIterminals
                                 {-# LINE 3117 "Order.hs" #-})
                            -- "Order.ag"(line 580, column 16)
                            _allfields =
                                ({-# LINE 580 "Order.ag" #-}
                                 _childrenIfields
                                 {-# LINE 3122 "Order.hs" #-})
                            -- "Order.ag"(line 580, column 16)
                            _attrs =
                                ({-# LINE 581 "Order.ag" #-}
                                 map ((,) _LOC)  _rulesIlocVars ++
                                 map ((,) _INST) _rulesIinstVars ++
                                 map ((,) _LHS)  _inhnames ++
                                 concat [map ((,) nm) (Map.keys as) | (nm,_,as) <- _childrenIattributes]
                                 {-# LINE 3130 "Order.hs" #-})
                            -- "Order.ag"(line 580, column 16)
                            _inhnames =
                                ({-# LINE 585 "Order.ag" #-}
                                 Map.keys _lhsIinh
                                 {-# LINE 3135 "Order.hs" #-})
                            -- "Order.ag"(line 580, column 16)
                            _synnames =
                                ({-# LINE 586 "Order.ag" #-}
                                 Map.keys _lhsIsyn
                                 {-# LINE 3140 "Order.hs" #-})
                            -- use rule "Order.ag"(line 249, column 33)
                            _lhsOdirectDep =
                                ({-# LINE 249 "Order.ag" #-}
                                 _rulesIdirectDep
                                 {-# LINE 3145 "Order.hs" #-})
                            -- use rule "Order.ag"(line 64, column 70)
                            _lhsOerrors =
                                ({-# LINE 64 "Order.ag" #-}
                                 _childrenIerrors Seq.>< _rulesIerrors
                                 {-# LINE 3150 "Order.hs" #-})
                            -- use rule "Order.ag"(line 292, column 31)
                            _lhsOinstDep =
                                ({-# LINE 292 "Order.ag" #-}
                                 _rulesIinstDep
                                 {-# LINE 3155 "Order.hs" #-})
                            -- copy rule (from local)
                            _childrenOallfields =
                                ({-# LINE 577 "Order.ag" #-}
                                 _allfields
                                 {-# LINE 3160 "Order.hs" #-})
                            -- copy rule (down)
                            _childrenOallnts =
                                ({-# LINE 570 "Order.ag" #-}
                                 _lhsIallnts
                                 {-# LINE 3165 "Order.hs" #-})
                            -- copy rule (from local)
                            _childrenOattrs =
                                ({-# LINE 577 "Order.ag" #-}
                                 _attrs
                                 {-# LINE 3170 "Order.hs" #-})
                            -- copy rule (down)
                            _childrenOinh =
                                ({-# LINE 69 "Order.ag" #-}
                                 _lhsIinh
                                 {-# LINE 3175 "Order.hs" #-})
                            -- copy rule (down)
                            _childrenOnt =
                                ({-# LINE 69 "Order.ag" #-}
                                 _lhsInt
                                 {-# LINE 3180 "Order.hs" #-})
                            -- copy rule (down)
                            _childrenOo_unbox =
                                ({-# LINE 99 "Order.ag" #-}
                                 _lhsIo_unbox
                                 {-# LINE 3185 "Order.hs" #-})
                            -- copy rule (down)
                            _childrenOsyn =
                                ({-# LINE 69 "Order.ag" #-}
                                 _lhsIsyn
                                 {-# LINE 3190 "Order.hs" #-})
                            -- copy rule (from local)
                            _rulesOallfields =
                                ({-# LINE 577 "Order.ag" #-}
                                 _allfields
                                 {-# LINE 3195 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOallnts =
                                ({-# LINE 570 "Order.ag" #-}
                                 _lhsIallnts
                                 {-# LINE 3200 "Order.hs" #-})
                            -- copy rule (from local)
                            _rulesOaltAttrs =
                                ({-# LINE 166 "Order.ag" #-}
                                 _altAttrs
                                 {-# LINE 3205 "Order.hs" #-})
                            -- copy rule (from local)
                            _rulesOattrs =
                                ({-# LINE 577 "Order.ag" #-}
                                 _attrs
                                 {-# LINE 3210 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOinh =
                                ({-# LINE 69 "Order.ag" #-}
                                 _lhsIinh
                                 {-# LINE 3215 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOnt =
                                ({-# LINE 69 "Order.ag" #-}
                                 _lhsInt
                                 {-# LINE 3220 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_case =
                                ({-# LINE 97 "Order.ag" #-}
                                 _lhsIo_case
                                 {-# LINE 3225 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_cata =
                                ({-# LINE 91 "Order.ag" #-}
                                 _lhsIo_cata
                                 {-# LINE 3230 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_dovisit =
                                ({-# LINE 96 "Order.ag" #-}
                                 _lhsIo_dovisit
                                 {-# LINE 3235 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_newtypes =
                                ({-# LINE 90 "Order.ag" #-}
                                 _lhsIo_newtypes
                                 {-# LINE 3240 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_rename =
                                ({-# LINE 94 "Order.ag" #-}
                                 _lhsIo_rename
                                 {-# LINE 3245 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_sem =
                                ({-# LINE 93 "Order.ag" #-}
                                 _lhsIo_sem
                                 {-# LINE 3250 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_sig =
                                ({-# LINE 92 "Order.ag" #-}
                                 _lhsIo_sig
                                 {-# LINE 3255 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOo_wantvisit =
                                ({-# LINE 95 "Order.ag" #-}
                                 _lhsIo_wantvisit
                                 {-# LINE 3260 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOprefix =
                                ({-# LINE 98 "Order.ag" #-}
                                 _lhsIprefix
                                 {-# LINE 3265 "Order.hs" #-})
                            -- copy rule (down)
                            _rulesOsyn =
                                ({-# LINE 69 "Order.ag" #-}
                                 _lhsIsyn
                                 {-# LINE 3270 "Order.hs" #-})
                            ( _childrenIattributes,_childrenIcollectChildrenInhs,_childrenIcollectChildrenSyns,_childrenIerrors,_childrenIfields,_childrenIgathAltAttrs,_childrenIgathRules,_childrenIinhs,_childrenInts,_childrenIsinglevisits,_childrenIterminals) =
                                (children_ _childrenOallfields _childrenOallnts _childrenOattrs _childrenOcon _childrenOinh _childrenOnt _childrenOo_unbox _childrenOsyn )
                            ( _rulesIdirectDep,_rulesIerrors,_rulesIgathAltAttrs,_rulesIgathRules,_rulesIinstDep,_rulesIinstVars,_rulesIlocVars) =
                                (rules_ _rulesOallTypeSigs _rulesOallfields _rulesOallnts _rulesOaltAttrs _rulesOattrs _rulesOchildInhs _rulesOchildNts _rulesOcon _rulesOinh _rulesOinhsOfChildren _rulesOnt _rulesOo_case _rulesOo_cata _rulesOo_dovisit _rulesOo_newtypes _rulesOo_rename _rulesOo_sem _rulesOo_sig _rulesOo_wantvisit _rulesOprefix _rulesOsyn _rulesOsynsOfChildren )
                            ( _typeSigsItypeSigs) =
                                (typeSigs_ _typeSigsOtypeSigs )
                        in  ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProduction,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount))) )
-- Productions -------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allnts               : [Identifier]
         aroundMap            : Map ConstructorIdent (Map Identifier [Expression])
         cVisitsMap           : CVisitsMap
         inh                  : Attributes
         manualAttrDepMap     : AttrOrderMap
         nt                   : Identifier
         o_case               : Bool
         o_cata               : Bool
         o_dovisit            : Bool
         o_newtypes           : Bool
         o_rename             : Bool
         o_sem                : Bool
         o_sig                : Bool
         o_unbox              : Bool
         o_wantvisit          : Bool
         prefix               : String
         syn                  : Attributes
      chained attribute:
         vcount               : Int
      synthesized attributes:
         additionalDep        : Seq Edge
         aroundDep            : Seq Edge
         cProductions         : CProductions
         cons                 : [ConstructorIdent]
         directDep            : Seq Edge
         errors               : Seq Error
         instDep              : Seq Edge
         rules                : Seq (Vertex,CRule)
   alternatives:
      alternative Cons:
         child hd             : Production 
         child tl             : Productions 
      alternative Nil:
-}
-- cata
sem_Productions :: Productions  ->
                   T_Productions 
sem_Productions list  =
    (Prelude.foldr sem_Productions_Cons sem_Productions_Nil (Prelude.map sem_Production list) )
-- semantic domain
newtype T_Productions  = T_Productions (([Identifier]) ->
                                        (Map ConstructorIdent (Map Identifier [Expression])) ->
                                        CVisitsMap ->
                                        Attributes ->
                                        AttrOrderMap ->
                                        Identifier ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        Bool ->
                                        String ->
                                        Attributes ->
                                        Int ->
                                        ( (Seq Edge),(Seq Edge),CProductions,([ConstructorIdent]),(Seq Edge),(Seq Error),(Seq Edge),(Seq (Vertex,CRule)),Int))
data Inh_Productions  = Inh_Productions {allnts_Inh_Productions :: !(([Identifier])),aroundMap_Inh_Productions :: !((Map ConstructorIdent (Map Identifier [Expression]))),cVisitsMap_Inh_Productions :: !(CVisitsMap),inh_Inh_Productions :: !(Attributes),manualAttrDepMap_Inh_Productions :: !(AttrOrderMap),nt_Inh_Productions :: !(Identifier),o_case_Inh_Productions :: !(Bool),o_cata_Inh_Productions :: !(Bool),o_dovisit_Inh_Productions :: !(Bool),o_newtypes_Inh_Productions :: !(Bool),o_rename_Inh_Productions :: !(Bool),o_sem_Inh_Productions :: !(Bool),o_sig_Inh_Productions :: !(Bool),o_unbox_Inh_Productions :: !(Bool),o_wantvisit_Inh_Productions :: !(Bool),prefix_Inh_Productions :: !(String),syn_Inh_Productions :: !(Attributes),vcount_Inh_Productions :: !(Int)}
data Syn_Productions  = Syn_Productions {additionalDep_Syn_Productions :: !((Seq Edge)),aroundDep_Syn_Productions :: !((Seq Edge)),cProductions_Syn_Productions :: !(CProductions),cons_Syn_Productions :: !(([ConstructorIdent])),directDep_Syn_Productions :: !((Seq Edge)),errors_Syn_Productions :: !((Seq Error)),instDep_Syn_Productions :: !((Seq Edge)),rules_Syn_Productions :: !((Seq (Vertex,CRule))),vcount_Syn_Productions :: !(Int)}
wrap_Productions :: T_Productions  ->
                    Inh_Productions  ->
                    Syn_Productions 
wrap_Productions (T_Productions sem ) (Inh_Productions _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount )  =
    (let ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProductions,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount) =
             (sem _lhsIallnts _lhsIaroundMap _lhsIcVisitsMap _lhsIinh _lhsImanualAttrDepMap _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_unbox _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIvcount )
     in  (Syn_Productions _lhsOadditionalDep _lhsOaroundDep _lhsOcProductions _lhsOcons _lhsOdirectDep _lhsOerrors _lhsOinstDep _lhsOrules _lhsOvcount ))
sem_Productions_Cons :: T_Production  ->
                        T_Productions  ->
                        T_Productions 
sem_Productions_Cons (T_Production hd_ ) (T_Productions tl_ )  =
    (T_Productions (\ _lhsIallnts
                      _lhsIaroundMap
                      _lhsIcVisitsMap
                      _lhsIinh
                      _lhsImanualAttrDepMap
                      _lhsInt
                      _lhsIo_case
                      _lhsIo_cata
                      _lhsIo_dovisit
                      _lhsIo_newtypes
                      _lhsIo_rename
                      _lhsIo_sem
                      _lhsIo_sig
                      _lhsIo_unbox
                      _lhsIo_wantvisit
                      _lhsIprefix
                      _lhsIsyn
                      _lhsIvcount ->
                        (let _lhsOcProductions :: CProductions
                             _lhsOadditionalDep :: (Seq Edge)
                             _lhsOaroundDep :: (Seq Edge)
                             _lhsOcons :: ([ConstructorIdent])
                             _lhsOdirectDep :: (Seq Edge)
                             _lhsOerrors :: (Seq Error)
                             _lhsOinstDep :: (Seq Edge)
                             _lhsOrules :: (Seq (Vertex,CRule))
                             _lhsOvcount :: Int
                             _hdOallnts :: ([Identifier])
                             _hdOaroundMap :: (Map ConstructorIdent (Map Identifier [Expression]))
                             _hdOcVisitsMap :: CVisitsMap
                             _hdOinh :: Attributes
                             _hdOmanualAttrDepMap :: AttrOrderMap
                             _hdOnt :: Identifier
                             _hdOo_case :: Bool
                             _hdOo_cata :: Bool
                             _hdOo_dovisit :: Bool
                             _hdOo_newtypes :: Bool
                             _hdOo_rename :: Bool
                             _hdOo_sem :: Bool
                             _hdOo_sig :: Bool
                             _hdOo_unbox :: Bool
                             _hdOo_wantvisit :: Bool
                             _hdOprefix :: String
                             _hdOsyn :: Attributes
                             _hdOvcount :: Int
                             _tlOallnts :: ([Identifier])
                             _tlOaroundMap :: (Map ConstructorIdent (Map Identifier [Expression]))
                             _tlOcVisitsMap :: CVisitsMap
                             _tlOinh :: Attributes
                             _tlOmanualAttrDepMap :: AttrOrderMap
                             _tlOnt :: Identifier
                             _tlOo_case :: Bool
                             _tlOo_cata :: Bool
                             _tlOo_dovisit :: Bool
                             _tlOo_newtypes :: Bool
                             _tlOo_rename :: Bool
                             _tlOo_sem :: Bool
                             _tlOo_sig :: Bool
                             _tlOo_unbox :: Bool
                             _tlOo_wantvisit :: Bool
                             _tlOprefix :: String
                             _tlOsyn :: Attributes
                             _tlOvcount :: Int
                             _hdIadditionalDep :: (Seq Edge)
                             _hdIaroundDep :: (Seq Edge)
                             _hdIcProduction :: CProduction
                             _hdIcons :: ([ConstructorIdent])
                             _hdIdirectDep :: (Seq Edge)
                             _hdIerrors :: (Seq Error)
                             _hdIinstDep :: (Seq Edge)
                             _hdIrules :: (Seq (Vertex,CRule))
                             _hdIvcount :: Int
                             _tlIadditionalDep :: (Seq Edge)
                             _tlIaroundDep :: (Seq Edge)
                             _tlIcProductions :: CProductions
                             _tlIcons :: ([ConstructorIdent])
                             _tlIdirectDep :: (Seq Edge)
                             _tlIerrors :: (Seq Error)
                             _tlIinstDep :: (Seq Edge)
                             _tlIrules :: (Seq (Vertex,CRule))
                             _tlIvcount :: Int
                             -- "Order.ag"(line 550, column 12)
                             _lhsOcProductions =
                                 ({-# LINE 550 "Order.ag" #-}
                                  _hdIcProduction : _tlIcProductions
                                  {-# LINE 3439 "Order.hs" #-})
                             -- use rule "Order.ag"(line 263, column 60)
                             _lhsOadditionalDep =
                                 ({-# LINE 263 "Order.ag" #-}
                                  _hdIadditionalDep Seq.>< _tlIadditionalDep
                                  {-# LINE 3444 "Order.hs" #-})
                             -- use rule "Order.ag"(line 338, column 24)
                             _lhsOaroundDep =
                                 ({-# LINE 338 "Order.ag" #-}
                                  _hdIaroundDep Seq.>< _tlIaroundDep
                                  {-# LINE 3449 "Order.hs" #-})
                             -- use rule "Order.ag"(line 445, column 40)
                             _lhsOcons =
                                 ({-# LINE 445 "Order.ag" #-}
                                  _hdIcons ++ _tlIcons
                                  {-# LINE 3454 "Order.hs" #-})
                             -- use rule "Order.ag"(line 249, column 33)
                             _lhsOdirectDep =
                                 ({-# LINE 249 "Order.ag" #-}
                                  _hdIdirectDep Seq.>< _tlIdirectDep
                                  {-# LINE 3459 "Order.hs" #-})
                             -- use rule "Order.ag"(line 64, column 70)
                             _lhsOerrors =
                                 ({-# LINE 64 "Order.ag" #-}
                                  _hdIerrors Seq.>< _tlIerrors
                                  {-# LINE 3464 "Order.hs" #-})
                             -- use rule "Order.ag"(line 292, column 31)
                             _lhsOinstDep =
                                 ({-# LINE 292 "Order.ag" #-}
                                  _hdIinstDep Seq.>< _tlIinstDep
                                  {-# LINE 3469 "Order.hs" #-})
                             -- use rule "Order.ag"(line 239, column 18)
                             _lhsOrules =
                                 ({-# LINE 239 "Order.ag" #-}
                                  _hdIrules Seq.>< _tlIrules
                                  {-# LINE 3474 "Order.hs" #-})
                             -- copy rule (up)
                             _lhsOvcount =
                                 ({-# LINE 238 "Order.ag" #-}
                                  _tlIvcount
                                  {-# LINE 3479 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOallnts =
                                 ({-# LINE 570 "Order.ag" #-}
                                  _lhsIallnts
                                  {-# LINE 3484 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOaroundMap =
                                 ({-# LINE 344 "Order.ag" #-}
                                  _lhsIaroundMap
                                  {-# LINE 3489 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOcVisitsMap =
                                 ({-# LINE 525 "Order.ag" #-}
                                  _lhsIcVisitsMap
                                  {-# LINE 3494 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOinh =
                                 ({-# LINE 69 "Order.ag" #-}
                                  _lhsIinh
                                  {-# LINE 3499 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOmanualAttrDepMap =
                                 ({-# LINE 263 "Order.ag" #-}
                                  _lhsImanualAttrDepMap
                                  {-# LINE 3504 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOnt =
                                 ({-# LINE 69 "Order.ag" #-}
                                  _lhsInt
                                  {-# LINE 3509 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_case =
                                 ({-# LINE 97 "Order.ag" #-}
                                  _lhsIo_case
                                  {-# LINE 3514 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_cata =
                                 ({-# LINE 91 "Order.ag" #-}
                                  _lhsIo_cata
                                  {-# LINE 3519 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_dovisit =
                                 ({-# LINE 96 "Order.ag" #-}
                                  _lhsIo_dovisit
                                  {-# LINE 3524 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_newtypes =
                                 ({-# LINE 90 "Order.ag" #-}
                                  _lhsIo_newtypes
                                  {-# LINE 3529 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_rename =
                                 ({-# LINE 94 "Order.ag" #-}
                                  _lhsIo_rename
                                  {-# LINE 3534 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_sem =
                                 ({-# LINE 93 "Order.ag" #-}
                                  _lhsIo_sem
                                  {-# LINE 3539 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_sig =
                                 ({-# LINE 92 "Order.ag" #-}
                                  _lhsIo_sig
                                  {-# LINE 3544 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_unbox =
                                 ({-# LINE 99 "Order.ag" #-}
                                  _lhsIo_unbox
                                  {-# LINE 3549 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOo_wantvisit =
                                 ({-# LINE 95 "Order.ag" #-}
                                  _lhsIo_wantvisit
                                  {-# LINE 3554 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOprefix =
                                 ({-# LINE 98 "Order.ag" #-}
                                  _lhsIprefix
                                  {-# LINE 3559 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOsyn =
                                 ({-# LINE 69 "Order.ag" #-}
                                  _lhsIsyn
                                  {-# LINE 3564 "Order.hs" #-})
                             -- copy rule (down)
                             _hdOvcount =
                                 ({-# LINE 238 "Order.ag" #-}
                                  _lhsIvcount
                                  {-# LINE 3569 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOallnts =
                                 ({-# LINE 570 "Order.ag" #-}
                                  _lhsIallnts
                                  {-# LINE 3574 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOaroundMap =
                                 ({-# LINE 344 "Order.ag" #-}
                                  _lhsIaroundMap
                                  {-# LINE 3579 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOcVisitsMap =
                                 ({-# LINE 525 "Order.ag" #-}
                                  _lhsIcVisitsMap
                                  {-# LINE 3584 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOinh =
                                 ({-# LINE 69 "Order.ag" #-}
                                  _lhsIinh
                                  {-# LINE 3589 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOmanualAttrDepMap =
                                 ({-# LINE 263 "Order.ag" #-}
                                  _lhsImanualAttrDepMap
                                  {-# LINE 3594 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOnt =
                                 ({-# LINE 69 "Order.ag" #-}
                                  _lhsInt
                                  {-# LINE 3599 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_case =
                                 ({-# LINE 97 "Order.ag" #-}
                                  _lhsIo_case
                                  {-# LINE 3604 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_cata =
                                 ({-# LINE 91 "Order.ag" #-}
                                  _lhsIo_cata
                                  {-# LINE 3609 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_dovisit =
                                 ({-# LINE 96 "Order.ag" #-}
                                  _lhsIo_dovisit
                                  {-# LINE 3614 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_newtypes =
                                 ({-# LINE 90 "Order.ag" #-}
                                  _lhsIo_newtypes
                                  {-# LINE 3619 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_rename =
                                 ({-# LINE 94 "Order.ag" #-}
                                  _lhsIo_rename
                                  {-# LINE 3624 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_sem =
                                 ({-# LINE 93 "Order.ag" #-}
                                  _lhsIo_sem
                                  {-# LINE 3629 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_sig =
                                 ({-# LINE 92 "Order.ag" #-}
                                  _lhsIo_sig
                                  {-# LINE 3634 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_unbox =
                                 ({-# LINE 99 "Order.ag" #-}
                                  _lhsIo_unbox
                                  {-# LINE 3639 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOo_wantvisit =
                                 ({-# LINE 95 "Order.ag" #-}
                                  _lhsIo_wantvisit
                                  {-# LINE 3644 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOprefix =
                                 ({-# LINE 98 "Order.ag" #-}
                                  _lhsIprefix
                                  {-# LINE 3649 "Order.hs" #-})
                             -- copy rule (down)
                             _tlOsyn =
                                 ({-# LINE 69 "Order.ag" #-}
                                  _lhsIsyn
                                  {-# LINE 3654 "Order.hs" #-})
                             -- copy rule (chain)
                             _tlOvcount =
                                 ({-# LINE 238 "Order.ag" #-}
                                  _hdIvcount
                                  {-# LINE 3659 "Order.hs" #-})
                             ( _hdIadditionalDep,_hdIaroundDep,_hdIcProduction,_hdIcons,_hdIdirectDep,_hdIerrors,_hdIinstDep,_hdIrules,_hdIvcount) =
                                 (hd_ _hdOallnts _hdOaroundMap _hdOcVisitsMap _hdOinh _hdOmanualAttrDepMap _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_unbox _hdOo_wantvisit _hdOprefix _hdOsyn _hdOvcount )
                             ( _tlIadditionalDep,_tlIaroundDep,_tlIcProductions,_tlIcons,_tlIdirectDep,_tlIerrors,_tlIinstDep,_tlIrules,_tlIvcount) =
                                 (tl_ _tlOallnts _tlOaroundMap _tlOcVisitsMap _tlOinh _tlOmanualAttrDepMap _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_unbox _tlOo_wantvisit _tlOprefix _tlOsyn _tlOvcount )
                         in  ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProductions,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount))) )
sem_Productions_Nil :: T_Productions 
sem_Productions_Nil  =
    (T_Productions (\ _lhsIallnts
                      _lhsIaroundMap
                      _lhsIcVisitsMap
                      _lhsIinh
                      _lhsImanualAttrDepMap
                      _lhsInt
                      _lhsIo_case
                      _lhsIo_cata
                      _lhsIo_dovisit
                      _lhsIo_newtypes
                      _lhsIo_rename
                      _lhsIo_sem
                      _lhsIo_sig
                      _lhsIo_unbox
                      _lhsIo_wantvisit
                      _lhsIprefix
                      _lhsIsyn
                      _lhsIvcount ->
                        (let _lhsOcProductions :: CProductions
                             _lhsOadditionalDep :: (Seq Edge)
                             _lhsOaroundDep :: (Seq Edge)
                             _lhsOcons :: ([ConstructorIdent])
                             _lhsOdirectDep :: (Seq Edge)
                             _lhsOerrors :: (Seq Error)
                             _lhsOinstDep :: (Seq Edge)
                             _lhsOrules :: (Seq (Vertex,CRule))
                             _lhsOvcount :: Int
                             -- "Order.ag"(line 551, column 12)
                             _lhsOcProductions =
                                 ({-# LINE 551 "Order.ag" #-}
                                  []
                                  {-# LINE 3698 "Order.hs" #-})
                             -- use rule "Order.ag"(line 263, column 60)
                             _lhsOadditionalDep =
                                 ({-# LINE 263 "Order.ag" #-}
                                  Seq.empty
                                  {-# LINE 3703 "Order.hs" #-})
                             -- use rule "Order.ag"(line 338, column 24)
                             _lhsOaroundDep =
                                 ({-# LINE 338 "Order.ag" #-}
                                  Seq.empty
                                  {-# LINE 3708 "Order.hs" #-})
                             -- use rule "Order.ag"(line 445, column 40)
                             _lhsOcons =
                                 ({-# LINE 445 "Order.ag" #-}
                                  []
                                  {-# LINE 3713 "Order.hs" #-})
                             -- use rule "Order.ag"(line 249, column 33)
                             _lhsOdirectDep =
                                 ({-# LINE 249 "Order.ag" #-}
                                  Seq.empty
                                  {-# LINE 3718 "Order.hs" #-})
                             -- use rule "Order.ag"(line 64, column 70)
                             _lhsOerrors =
                                 ({-# LINE 64 "Order.ag" #-}
                                  Seq.empty
                                  {-# LINE 3723 "Order.hs" #-})
                             -- use rule "Order.ag"(line 292, column 31)
                             _lhsOinstDep =
                                 ({-# LINE 292 "Order.ag" #-}
                                  Seq.empty
                                  {-# LINE 3728 "Order.hs" #-})
                             -- use rule "Order.ag"(line 239, column 18)
                             _lhsOrules =
                                 ({-# LINE 239 "Order.ag" #-}
                                  Seq.empty
                                  {-# LINE 3733 "Order.hs" #-})
                             -- copy rule (chain)
                             _lhsOvcount =
                                 ({-# LINE 238 "Order.ag" #-}
                                  _lhsIvcount
                                  {-# LINE 3738 "Order.hs" #-})
                         in  ( _lhsOadditionalDep,_lhsOaroundDep,_lhsOcProductions,_lhsOcons,_lhsOdirectDep,_lhsOerrors,_lhsOinstDep,_lhsOrules,_lhsOvcount))) )
-- Rule --------------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allTypeSigs          : Map Identifier Type
         allfields            : [(Identifier,Type,Bool)]
         allnts               : [Identifier]
         altAttrs             : Map AltAttr Vertex
         attrs                : [(Identifier,Identifier)]
         childInhs            : Map Identifier Attributes
         childNts             : Map Identifier NontermIdent
         con                  : Identifier
         inh                  : Attributes
         inhsOfChildren       : Map Identifier Attributes
         nt                   : Identifier
         o_case               : Bool
         o_cata               : Bool
         o_dovisit            : Bool
         o_newtypes           : Bool
         o_rename             : Bool
         o_sem                : Bool
         o_sig                : Bool
         o_wantvisit          : Bool
         prefix               : String
         syn                  : Attributes
         synsOfChildren       : Map Identifier Attributes
      synthesized attributes:
         directDep            : Seq Edge
         errors               : Seq Error
         gathAltAttrs         : [AltAttr]
         gathRules            : Seq CRule
         instDep              : Seq Edge
         instVars             : [Identifier]
         locVars              : [Identifier]
   alternatives:
      alternative Rule:
         child mbName         : {Maybe Identifier}
         child pattern        : Pattern 
         child rhs            : Expression 
         child owrt           : {Bool}
         child origin         : {String}
         child explicit       : {Bool}
         visit 0:
            local defines     : _
            local gathRules   : _
            local instDep1    : _
            local instDep2    : _
-}
-- cata
sem_Rule :: Rule  ->
            T_Rule 
sem_Rule (Rule _mbName _pattern _rhs _owrt _origin _explicit )  =
    (sem_Rule_Rule _mbName (sem_Pattern _pattern ) (sem_Expression _rhs ) _owrt _origin _explicit )
-- semantic domain
newtype T_Rule  = T_Rule ((Map Identifier Type) ->
                          ([(Identifier,Type,Bool)]) ->
                          ([Identifier]) ->
                          (Map AltAttr Vertex) ->
                          ([(Identifier,Identifier)]) ->
                          (Map Identifier Attributes) ->
                          (Map Identifier NontermIdent) ->
                          Identifier ->
                          Attributes ->
                          (Map Identifier Attributes) ->
                          Identifier ->
                          Bool ->
                          Bool ->
                          Bool ->
                          Bool ->
                          Bool ->
                          Bool ->
                          Bool ->
                          Bool ->
                          String ->
                          Attributes ->
                          (Map Identifier Attributes) ->
                          ( (Seq Edge),(Seq Error),([AltAttr]),(Seq CRule),(Seq Edge),([Identifier]),([Identifier])))
data Inh_Rule  = Inh_Rule {allTypeSigs_Inh_Rule :: !((Map Identifier Type)),allfields_Inh_Rule :: !(([(Identifier,Type,Bool)])),allnts_Inh_Rule :: !(([Identifier])),altAttrs_Inh_Rule :: !((Map AltAttr Vertex)),attrs_Inh_Rule :: !(([(Identifier,Identifier)])),childInhs_Inh_Rule :: !((Map Identifier Attributes)),childNts_Inh_Rule :: !((Map Identifier NontermIdent)),con_Inh_Rule :: !(Identifier),inh_Inh_Rule :: !(Attributes),inhsOfChildren_Inh_Rule :: !((Map Identifier Attributes)),nt_Inh_Rule :: !(Identifier),o_case_Inh_Rule :: !(Bool),o_cata_Inh_Rule :: !(Bool),o_dovisit_Inh_Rule :: !(Bool),o_newtypes_Inh_Rule :: !(Bool),o_rename_Inh_Rule :: !(Bool),o_sem_Inh_Rule :: !(Bool),o_sig_Inh_Rule :: !(Bool),o_wantvisit_Inh_Rule :: !(Bool),prefix_Inh_Rule :: !(String),syn_Inh_Rule :: !(Attributes),synsOfChildren_Inh_Rule :: !((Map Identifier Attributes))}
data Syn_Rule  = Syn_Rule {directDep_Syn_Rule :: !((Seq Edge)),errors_Syn_Rule :: !((Seq Error)),gathAltAttrs_Syn_Rule :: !(([AltAttr])),gathRules_Syn_Rule :: !((Seq CRule)),instDep_Syn_Rule :: !((Seq Edge)),instVars_Syn_Rule :: !(([Identifier])),locVars_Syn_Rule :: !(([Identifier]))}
wrap_Rule :: T_Rule  ->
             Inh_Rule  ->
             Syn_Rule 
wrap_Rule (T_Rule sem ) (Inh_Rule _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren )  =
    (let ( _lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars) =
             (sem _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren )
     in  (Syn_Rule _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars ))
sem_Rule_Rule :: (Maybe Identifier) ->
                 T_Pattern  ->
                 T_Expression  ->
                 Bool ->
                 String ->
                 Bool ->
                 T_Rule 
sem_Rule_Rule mbName_ (T_Pattern pattern_ ) (T_Expression rhs_ ) owrt_ origin_ explicit_  =
    (T_Rule (\ _lhsIallTypeSigs
               _lhsIallfields
               _lhsIallnts
               _lhsIaltAttrs
               _lhsIattrs
               _lhsIchildInhs
               _lhsIchildNts
               _lhsIcon
               _lhsIinh
               _lhsIinhsOfChildren
               _lhsInt
               _lhsIo_case
               _lhsIo_cata
               _lhsIo_dovisit
               _lhsIo_newtypes
               _lhsIo_rename
               _lhsIo_sem
               _lhsIo_sig
               _lhsIo_wantvisit
               _lhsIprefix
               _lhsIsyn
               _lhsIsynsOfChildren ->
                 (let _lhsOdirectDep :: (Seq Edge)
                      _lhsOinstDep :: (Seq Edge)
                      _lhsOerrors :: (Seq Error)
                      _lhsOgathAltAttrs :: ([AltAttr])
                      _lhsOgathRules :: (Seq CRule)
                      _lhsOinstVars :: ([Identifier])
                      _lhsOlocVars :: ([Identifier])
                      _patternOallTypeSigs :: (Map Identifier Type)
                      _patternOaltAttrs :: (Map AltAttr Vertex)
                      _patternOcon :: Identifier
                      _patternOinh :: Attributes
                      _patternOnt :: Identifier
                      _patternOsyn :: Attributes
                      _rhsOallfields :: ([(Identifier,Type,Bool)])
                      _rhsOallnts :: ([Identifier])
                      _rhsOattrs :: ([(Identifier,Identifier)])
                      _rhsOcon :: Identifier
                      _rhsOnt :: Identifier
                      _patternIcopy :: Pattern 
                      _patternIerrors :: (Seq Error)
                      _patternIgathAltAttrs :: ([AltAttr])
                      _patternIinstVars :: ([Identifier])
                      _patternIlocVars :: ([Identifier])
                      _patternIpatternAttrs :: ([(Identifier,Identifier,Bool,Patterns)])
                      _rhsIallRhsVars :: (Set (Identifier,Identifier))
                      _rhsIcopy :: Expression 
                      _rhsIerrors :: (Seq Error)
                      _rhsItextLines :: ([String])
                      _rhsIusedAttrs :: ([(Identifier,Identifier)])
                      _rhsIusedFields :: ([Identifier])
                      _rhsIusedLocals :: ([Identifier])
                      -- "Order.ag"(line 197, column 12)
                      _defines =
                          ({-# LINE 197 "Order.ag" #-}
                           let  tp field attr parts | field == _LOC || field == _INST
                                                                    = case parts of
                                                                        [] -> Map.lookup attr _lhsIallTypeSigs
                                                                        _  -> (sequence (map typ parts)) >>= (haskellTupel . map (substSelf _lhsInt))
                                                    | field == _LHS = Map.lookup attr _lhsIsyn
                                                    | otherwise     = Map.lookup attr (findWithErr1 "Rule.defines.tp" field _lhsIchildInhs)
                                typ :: Pattern -> Maybe Type
                                typ (Alias field attr _ parts) = tp field attr parts
                                typ (Underscore _)             = Nothing
                                typ (Product _ pats)           = tp _LOC undefined pats
                                typ _                          = Nothing
                           in Map.fromList  [ (findWithErr1 "Rule.defines" aa _lhsIaltAttrs, (field,attr,(tp field attr parts)))
                                            | (field,attr,isLocalOrInst,parts) <- _patternIpatternAttrs
                                            , let aa = AltAttr field attr isLocalOrInst
                                            ]
                           {-# LINE 3905 "Order.hs" #-})
                      -- "Order.ag"(line 213, column 12)
                      _gathRules =
                          ({-# LINE 213 "Order.ag" #-}
                           let childnt field = Map.lookup field _lhsIchildNts
                           in Seq.fromList [ CRule attr False True _lhsInt _lhsIcon field (childnt field) tp _patternIcopy _rhsItextLines _defines owrt_ origin_ _rhsIallRhsVars explicit_ mbName_
                                           | (field,attr,tp) <- Map.elems _defines
                                           ]
                           {-# LINE 3913 "Order.hs" #-})
                      -- "Order.ag"(line 251, column 12)
                      _lhsOdirectDep =
                          ({-# LINE 251 "Order.ag" #-}
                           let  defined = Map.keys _defines
                                used =  [ Map.lookup (AltAttr field attr True) _lhsIaltAttrs | (field,attr) <- _rhsIusedAttrs]
                                        ++ [ Map.lookup (AltAttr _LOC attr True) _lhsIaltAttrs | attr <- _rhsIusedLocals ++ _rhsIusedFields ]
                           in Seq.fromList [ (x,y) | Just x <- used, y <- defined ]
                           {-# LINE 3921 "Order.hs" #-})
                      -- "Order.ag"(line 295, column 6)
                      _instDep1 =
                          ({-# LINE 295 "Order.ag" #-}
                           Seq.fromList $
                             [ (instVert, synVert)
                             | (field,instNm,_) <- Map.elems _defines
                             , field == _INST
                             , synNm <- Map.keys (findWithErr2 instNm _lhsIsynsOfChildren)
                             , let instAttr = AltAttr _INST instNm True
                                   synAttr  = AltAttr instNm synNm True
                                   instVert = findWithErr2 instAttr _lhsIaltAttrs
                                   synVert  = findWithErr2 synAttr _lhsIaltAttrs
                             ]
                           {-# LINE 3935 "Order.hs" #-})
                      -- "Order.ag"(line 306, column 6)
                      _instDep2 =
                          ({-# LINE 306 "Order.ag" #-}
                           Seq.fromList $
                             [ (instVert, inhVert)
                             | (field,instNm,_) <- Map.elems _defines
                             , field == _INST
                             , inhNm <- Map.keys (findWithErr2 instNm _lhsIinhsOfChildren)
                             , let instAttr = AltAttr _INST instNm True
                                   inhAttr  = AltAttr instNm inhNm False
                                   instVert = findWithErr2 instAttr _lhsIaltAttrs
                                   inhVert  = findWithErr2 inhAttr _lhsIaltAttrs
                             ]
                           {-# LINE 3949 "Order.hs" #-})
                      -- "Order.ag"(line 317, column 6)
                      _lhsOinstDep =
                          ({-# LINE 317 "Order.ag" #-}
                           _instDep1     Seq.>< _instDep2
                           {-# LINE 3954 "Order.hs" #-})
                      -- use rule "Order.ag"(line 64, column 70)
                      _lhsOerrors =
                          ({-# LINE 64 "Order.ag" #-}
                           _patternIerrors Seq.>< _rhsIerrors
                           {-# LINE 3959 "Order.hs" #-})
                      -- use rule "Order.ag"(line 150, column 68)
                      _lhsOgathAltAttrs =
                          ({-# LINE 150 "Order.ag" #-}
                           _patternIgathAltAttrs
                           {-# LINE 3964 "Order.hs" #-})
                      -- use rule "Order.ag"(line 186, column 23)
                      _lhsOgathRules =
                          ({-# LINE 186 "Order.ag" #-}
                           _gathRules
                           {-# LINE 3969 "Order.hs" #-})
                      -- use rule "Order.ag"(line 600, column 86)
                      _lhsOinstVars =
                          ({-# LINE 600 "Order.ag" #-}
                           _patternIinstVars
                           {-# LINE 3974 "Order.hs" #-})
                      -- use rule "Order.ag"(line 600, column 48)
                      _lhsOlocVars =
                          ({-# LINE 600 "Order.ag" #-}
                           _patternIlocVars
                           {-# LINE 3979 "Order.hs" #-})
                      -- copy rule (down)
                      _patternOallTypeSigs =
                          ({-# LINE 458 "Order.ag" #-}
                           _lhsIallTypeSigs
                           {-# LINE 3984 "Order.hs" #-})
                      -- copy rule (down)
                      _patternOaltAttrs =
                          ({-# LINE 166 "Order.ag" #-}
                           _lhsIaltAttrs
                           {-# LINE 3989 "Order.hs" #-})
                      -- copy rule (down)
                      _patternOcon =
                          ({-# LINE 70 "Order.ag" #-}
                           _lhsIcon
                           {-# LINE 3994 "Order.hs" #-})
                      -- copy rule (down)
                      _patternOinh =
                          ({-# LINE 69 "Order.ag" #-}
                           _lhsIinh
                           {-# LINE 3999 "Order.hs" #-})
                      -- copy rule (down)
                      _patternOnt =
                          ({-# LINE 69 "Order.ag" #-}
                           _lhsInt
                           {-# LINE 4004 "Order.hs" #-})
                      -- copy rule (down)
                      _patternOsyn =
                          ({-# LINE 69 "Order.ag" #-}
                           _lhsIsyn
                           {-# LINE 4009 "Order.hs" #-})
                      -- copy rule (down)
                      _rhsOallfields =
                          ({-# LINE 382 "Order.ag" #-}
                           _lhsIallfields
                           {-# LINE 4014 "Order.hs" #-})
                      -- copy rule (down)
                      _rhsOallnts =
                          ({-# LINE 383 "Order.ag" #-}
                           _lhsIallnts
                           {-# LINE 4019 "Order.hs" #-})
                      -- copy rule (down)
                      _rhsOattrs =
                          ({-# LINE 384 "Order.ag" #-}
                           _lhsIattrs
                           {-# LINE 4024 "Order.hs" #-})
                      -- copy rule (down)
                      _rhsOcon =
                          ({-# LINE 381 "Order.ag" #-}
                           _lhsIcon
                           {-# LINE 4029 "Order.hs" #-})
                      -- copy rule (down)
                      _rhsOnt =
                          ({-# LINE 381 "Order.ag" #-}
                           _lhsInt
                           {-# LINE 4034 "Order.hs" #-})
                      ( _patternIcopy,_patternIerrors,_patternIgathAltAttrs,_patternIinstVars,_patternIlocVars,_patternIpatternAttrs) =
                          (pattern_ _patternOallTypeSigs _patternOaltAttrs _patternOcon _patternOinh _patternOnt _patternOsyn )
                      ( _rhsIallRhsVars,_rhsIcopy,_rhsIerrors,_rhsItextLines,_rhsIusedAttrs,_rhsIusedFields,_rhsIusedLocals) =
                          (rhs_ _rhsOallfields _rhsOallnts _rhsOattrs _rhsOcon _rhsOnt )
                  in  ( _lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars))) )
-- Rules -------------------------------------------------------
{-
   visit 0:
      inherited attributes:
         allTypeSigs          : Map Identifier Type
         allfields            : [(Identifier,Type,Bool)]
         allnts               : [Identifier]
         altAttrs             : Map AltAttr Vertex
         attrs                : [(Identifier,Identifier)]
         childInhs            : Map Identifier Attributes
         childNts             : Map Identifier NontermIdent
         con                  : Identifier
         inh                  : Attributes
         inhsOfChildren       : Map Identifier Attributes
         nt                   : Identifier
         o_case               : Bool
         o_cata               : Bool
         o_dovisit            : Bool
         o_newtypes           : Bool
         o_rename             : Bool
         o_sem                : Bool
         o_sig                : Bool
         o_wantvisit          : Bool
         prefix               : String
         syn                  : Attributes
         synsOfChildren       : Map Identifier Attributes
      synthesized attributes:
         directDep            : Seq Edge
         errors               : Seq Error
         gathAltAttrs         : [AltAttr]
         gathRules            : Seq CRule
         instDep              : Seq Edge
         instVars             : [Identifier]
         locVars              : [Identifier]
   alternatives:
      alternative Cons:
         child hd             : Rule 
         child tl             : Rules 
      alternative Nil:
-}
-- cata
sem_Rules :: Rules  ->
             T_Rules 
sem_Rules list  =
    (Prelude.foldr sem_Rules_Cons sem_Rules_Nil (Prelude.map sem_Rule list) )
-- semantic domain
newtype T_Rules  = T_Rules ((Map Identifier Type) ->
                            ([(Identifier,Type,Bool)]) ->
                            ([Identifier]) ->
                            (Map AltAttr Vertex) ->
                            ([(Identifier,Identifier)]) ->
                            (Map Identifier Attributes) ->
                            (Map Identifier NontermIdent) ->
                            Identifier ->
                            Attributes ->
                            (Map Identifier Attributes) ->
                            Identifier ->
                            Bool ->
                            Bool ->
                            Bool ->
                            Bool ->
                            Bool ->
                            Bool ->
                            Bool ->
                            Bool ->
                            String ->
                            Attributes ->
                            (Map Identifier Attributes) ->
                            ( (Seq Edge),(Seq Error),([AltAttr]),(Seq CRule),(Seq Edge),([Identifier]),([Identifier])))
data Inh_Rules  = Inh_Rules {allTypeSigs_Inh_Rules :: !((Map Identifier Type)),allfields_Inh_Rules :: !(([(Identifier,Type,Bool)])),allnts_Inh_Rules :: !(([Identifier])),altAttrs_Inh_Rules :: !((Map AltAttr Vertex)),attrs_Inh_Rules :: !(([(Identifier,Identifier)])),childInhs_Inh_Rules :: !((Map Identifier Attributes)),childNts_Inh_Rules :: !((Map Identifier NontermIdent)),con_Inh_Rules :: !(Identifier),inh_Inh_Rules :: !(Attributes),inhsOfChildren_Inh_Rules :: !((Map Identifier Attributes)),nt_Inh_Rules :: !(Identifier),o_case_Inh_Rules :: !(Bool),o_cata_Inh_Rules :: !(Bool),o_dovisit_Inh_Rules :: !(Bool),o_newtypes_Inh_Rules :: !(Bool),o_rename_Inh_Rules :: !(Bool),o_sem_Inh_Rules :: !(Bool),o_sig_Inh_Rules :: !(Bool),o_wantvisit_Inh_Rules :: !(Bool),prefix_Inh_Rules :: !(String),syn_Inh_Rules :: !(Attributes),synsOfChildren_Inh_Rules :: !((Map Identifier Attributes))}
data Syn_Rules  = Syn_Rules {directDep_Syn_Rules :: !((Seq Edge)),errors_Syn_Rules :: !((Seq Error)),gathAltAttrs_Syn_Rules :: !(([AltAttr])),gathRules_Syn_Rules :: !((Seq CRule)),instDep_Syn_Rules :: !((Seq Edge)),instVars_Syn_Rules :: !(([Identifier])),locVars_Syn_Rules :: !(([Identifier]))}
wrap_Rules :: T_Rules  ->
              Inh_Rules  ->
              Syn_Rules 
wrap_Rules (T_Rules sem ) (Inh_Rules _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren )  =
    (let ( _lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars) =
             (sem _lhsIallTypeSigs _lhsIallfields _lhsIallnts _lhsIaltAttrs _lhsIattrs _lhsIchildInhs _lhsIchildNts _lhsIcon _lhsIinh _lhsIinhsOfChildren _lhsInt _lhsIo_case _lhsIo_cata _lhsIo_dovisit _lhsIo_newtypes _lhsIo_rename _lhsIo_sem _lhsIo_sig _lhsIo_wantvisit _lhsIprefix _lhsIsyn _lhsIsynsOfChildren )
     in  (Syn_Rules _lhsOdirectDep _lhsOerrors _lhsOgathAltAttrs _lhsOgathRules _lhsOinstDep _lhsOinstVars _lhsOlocVars ))
sem_Rules_Cons :: T_Rule  ->
                  T_Rules  ->
                  T_Rules 
sem_Rules_Cons (T_Rule hd_ ) (T_Rules tl_ )  =
    (T_Rules (\ _lhsIallTypeSigs
                _lhsIallfields
                _lhsIallnts
                _lhsIaltAttrs
                _lhsIattrs
                _lhsIchildInhs
                _lhsIchildNts
                _lhsIcon
                _lhsIinh
                _lhsIinhsOfChildren
                _lhsInt
                _lhsIo_case
                _lhsIo_cata
                _lhsIo_dovisit
                _lhsIo_newtypes
                _lhsIo_rename
                _lhsIo_sem
                _lhsIo_sig
                _lhsIo_wantvisit
                _lhsIprefix
                _lhsIsyn
                _lhsIsynsOfChildren ->
                  (let _lhsOdirectDep :: (Seq Edge)
                       _lhsOerrors :: (Seq Error)
                       _lhsOgathAltAttrs :: ([AltAttr])
                       _lhsOgathRules :: (Seq CRule)
                       _lhsOinstDep :: (Seq Edge)
                       _lhsOinstVars :: ([Identifier])
                       _lhsOlocVars :: ([Identifier])
                       _hdOallTypeSigs :: (Map Identifier Type)
                       _hdOallfields :: ([(Identifier,Type,Bool)])
                       _hdOallnts :: ([Identifier])
                       _hdOaltAttrs :: (Map AltAttr Vertex)
                       _hdOattrs :: ([(Identifier,Identifier)])
                       _hdOchildInhs :: (Map Identifier Attributes)
                       _hdOchildNts :: (Map Identifier NontermIdent)
                       _hdOcon :: Identifier
                       _hdOinh :: Attributes
                       _hdOinhsOfChildren :: (Map Identifier Attributes)
                       _hdOnt :: Identifier
                       _hdOo_case :: Bool
                       _hdOo_cata :: Bool
                       _hdOo_dovisit :: Bool
                       _hdOo_newtypes :: Bool
                       _hdOo_rename :: Bool
                       _hdOo_sem :: Bool
                       _hdOo_sig :: Bool
                       _hdOo_wantvisit :: Bool
                       _hdOprefix :: String
                       _hdOsyn :: Attributes
                       _hdOsynsOfChildren :: (Map Identifier Attributes)
                       _tlOallTypeSigs :: (Map Identifier Type)
                       _tlOallfields :: ([(Identifier,Type,Bool)])
                       _tlOallnts :: ([Identifier])
                       _tlOaltAttrs :: (Map AltAttr Vertex)
                       _tlOattrs :: ([(Identifier,Identifier)])
                       _tlOchildInhs :: (Map Identifier Attributes)
                       _tlOchildNts :: (Map Identifier NontermIdent)
                       _tlOcon :: Identifier
                       _tlOinh :: Attributes
                       _tlOinhsOfChildren :: (Map Identifier Attributes)
                       _tlOnt :: Identifier
                       _tlOo_case :: Bool
                       _tlOo_cata :: Bool
                       _tlOo_dovisit :: Bool
                       _tlOo_newtypes :: Bool
                       _tlOo_rename :: Bool
                       _tlOo_sem :: Bool
                       _tlOo_sig :: Bool
                       _tlOo_wantvisit :: Bool
                       _tlOprefix :: String
                       _tlOsyn :: Attributes
                       _tlOsynsOfChildren :: (Map Identifier Attributes)
                       _hdIdirectDep :: (Seq Edge)
                       _hdIerrors :: (Seq Error)
                       _hdIgathAltAttrs :: ([AltAttr])
                       _hdIgathRules :: (Seq CRule)
                       _hdIinstDep :: (Seq Edge)
                       _hdIinstVars :: ([Identifier])
                       _hdIlocVars :: ([Identifier])
                       _tlIdirectDep :: (Seq Edge)
                       _tlIerrors :: (Seq Error)
                       _tlIgathAltAttrs :: ([AltAttr])
                       _tlIgathRules :: (Seq CRule)
                       _tlIinstDep :: (Seq Edge)
                       _tlIinstVars :: ([Identifier])
                       _tlIlocVars :: ([Identifier])
                       -- use rule "Order.ag"(line 249, column 33)
                       _lhsOdirectDep =
                           ({-# LINE 249 "Order.ag" #-}
                            _hdIdirectDep Seq.>< _tlIdirectDep
                            {-# LINE 4213 "Order.hs" #-})
                       -- use rule "Order.ag"(line 64, column 70)
                       _lhsOerrors =
                           ({-# LINE 64 "Order.ag" #-}
                            _hdIerrors Seq.>< _tlIerrors
                            {-# LINE 4218 "Order.hs" #-})
                       -- use rule "Order.ag"(line 150, column 68)
                       _lhsOgathAltAttrs =
                           ({-# LINE 150 "Order.ag" #-}
                            _hdIgathAltAttrs ++ _tlIgathAltAttrs
                            {-# LINE 4223 "Order.hs" #-})
                       -- use rule "Order.ag"(line 186, column 23)
                       _lhsOgathRules =
                           ({-# LINE 186 "Order.ag" #-}
                            _hdIgathRules Seq.>< _tlIgathRules
                            {-# LINE 4228 "Order.hs" #-})
                       -- use rule "Order.ag"(line 292, column 31)
                       _lhsOinstDep =
                           ({-# LINE 292 "Order.ag" #-}
                            _hdIinstDep Seq.>< _tlIinstDep
                            {-# LINE 4233 "Order.hs" #-})
                       -- use rule "Order.ag"(line 600, column 86)
                       _lhsOinstVars =
                           ({-# LINE 600 "Order.ag" #-}
                            _hdIinstVars ++ _tlIinstVars
                            {-# LINE 4238 "Order.hs" #-})
                       -- use rule "Order.ag"(line 600, column 48)
                       _lhsOlocVars =
                           ({-# LINE 600 "Order.ag" #-}
                            _hdIlocVars ++ _tlIlocVars
                            {-# LINE 4243 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOallTypeSigs =
                           ({-# LINE 458 "Order.ag" #-}
                            _lhsIallTypeSigs
                            {-# LINE 4248 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOallfields =
                           ({-# LINE 577 "Order.ag" #-}
                            _lhsIallfields
                            {-# LINE 4253 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOallnts =
                           ({-# LINE 570 "Order.ag" #-}
                            _lhsIallnts
                            {-# LINE 4258 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOaltAttrs =
                           ({-# LINE 166 "Order.ag" #-}
                            _lhsIaltAttrs
                            {-# LINE 4263 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOattrs =
                           ({-# LINE 577 "Order.ag" #-}
                            _lhsIattrs
                            {-# LINE 4268 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOchildInhs =
                           ({-# LINE 179 "Order.ag" #-}
                            _lhsIchildInhs
                            {-# LINE 4273 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOchildNts =
                           ({-# LINE 178 "Order.ag" #-}
                            _lhsIchildNts
                            {-# LINE 4278 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOcon =
                           ({-# LINE 70 "Order.ag" #-}
                            _lhsIcon
                            {-# LINE 4283 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOinh =
                           ({-# LINE 69 "Order.ag" #-}
                            _lhsIinh
                            {-# LINE 4288 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOinhsOfChildren =
                           ({-# LINE 319 "Order.ag" #-}
                            _lhsIinhsOfChildren
                            {-# LINE 4293 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOnt =
                           ({-# LINE 69 "Order.ag" #-}
                            _lhsInt
                            {-# LINE 4298 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_case =
                           ({-# LINE 97 "Order.ag" #-}
                            _lhsIo_case
                            {-# LINE 4303 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_cata =
                           ({-# LINE 91 "Order.ag" #-}
                            _lhsIo_cata
                            {-# LINE 4308 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_dovisit =
                           ({-# LINE 96 "Order.ag" #-}
                            _lhsIo_dovisit
                            {-# LINE 4313 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_newtypes =
                           ({-# LINE 90 "Order.ag" #-}
                            _lhsIo_newtypes
                            {-# LINE 4318 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_rename =
                           ({-# LINE 94 "Order.ag" #-}
                            _lhsIo_rename
                            {-# LINE 4323 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_sem =
                           ({-# LINE 93 "Order.ag" #-}
                            _lhsIo_sem
                            {-# LINE 4328 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_sig =
                           ({-# LINE 92 "Order.ag" #-}
                            _lhsIo_sig
                            {-# LINE 4333 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOo_wantvisit =
                           ({-# LINE 95 "Order.ag" #-}
                            _lhsIo_wantvisit
                            {-# LINE 4338 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOprefix =
                           ({-# LINE 98 "Order.ag" #-}
                            _lhsIprefix
                            {-# LINE 4343 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOsyn =
                           ({-# LINE 69 "Order.ag" #-}
                            _lhsIsyn
                            {-# LINE 4348 "Order.hs" #-})
                       -- copy rule (down)
                       _hdOsynsOfChildren =
                           ({-# LINE 319 "Order.ag" #-}
                            _lhsIsynsOfChildren
                            {-# LINE 4353 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOallTypeSigs =
                           ({-# LINE 458 "Order.ag" #-}
                            _lhsIallTypeSigs
                            {-# LINE 4358 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOallfields =
                           ({-# LINE 577 "Order.ag" #-}
                            _lhsIallfields
                            {-# LINE 4363 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOallnts =
                           ({-# LINE 570 "Order.ag" #-}
                            _lhsIallnts
                            {-# LINE 4368 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOaltAttrs =
                           ({-# LINE 166 "Order.ag" #-}
                            _lhsIaltAttrs
                            {-# LINE 4373 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOattrs =
                           ({-# LINE 577 "Order.ag" #-}
                            _lhsIattrs
                            {-# LINE 4378 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOchildInhs =
                           ({-# LINE 179 "Order.ag" #-}
                            _lhsIchildInhs
                            {-# LINE 4383 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOchildNts =
                           ({-# LINE 178 "Order.ag" #-}
                            _lhsIchildNts
                            {-# LINE 4388 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOcon =
                           ({-# LINE 70 "Order.ag" #-}
                            _lhsIcon
                            {-# LINE 4393 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOinh =
                           ({-# LINE 69 "Order.ag" #-}
                            _lhsIinh
                            {-# LINE 4398 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOinhsOfChildren =
                           ({-# LINE 319 "Order.ag" #-}
                            _lhsIinhsOfChildren
                            {-# LINE 4403 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOnt =
                           ({-# LINE 69 "Order.ag" #-}
                            _lhsInt
                            {-# LINE 4408 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_case =
                           ({-# LINE 97 "Order.ag" #-}
                            _lhsIo_case
                            {-# LINE 4413 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_cata =
                           ({-# LINE 91 "Order.ag" #-}
                            _lhsIo_cata
                            {-# LINE 4418 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_dovisit =
                           ({-# LINE 96 "Order.ag" #-}
                            _lhsIo_dovisit
                            {-# LINE 4423 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_newtypes =
                           ({-# LINE 90 "Order.ag" #-}
                            _lhsIo_newtypes
                            {-# LINE 4428 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_rename =
                           ({-# LINE 94 "Order.ag" #-}
                            _lhsIo_rename
                            {-# LINE 4433 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_sem =
                           ({-# LINE 93 "Order.ag" #-}
                            _lhsIo_sem
                            {-# LINE 4438 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_sig =
                           ({-# LINE 92 "Order.ag" #-}
                            _lhsIo_sig
                            {-# LINE 4443 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOo_wantvisit =
                           ({-# LINE 95 "Order.ag" #-}
                            _lhsIo_wantvisit
                            {-# LINE 4448 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOprefix =
                           ({-# LINE 98 "Order.ag" #-}
                            _lhsIprefix
                            {-# LINE 4453 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOsyn =
                           ({-# LINE 69 "Order.ag" #-}
                            _lhsIsyn
                            {-# LINE 4458 "Order.hs" #-})
                       -- copy rule (down)
                       _tlOsynsOfChildren =
                           ({-# LINE 319 "Order.ag" #-}
                            _lhsIsynsOfChildren
                            {-# LINE 4463 "Order.hs" #-})
                       ( _hdIdirectDep,_hdIerrors,_hdIgathAltAttrs,_hdIgathRules,_hdIinstDep,_hdIinstVars,_hdIlocVars) =
                           (hd_ _hdOallTypeSigs _hdOallfields _hdOallnts _hdOaltAttrs _hdOattrs _hdOchildInhs _hdOchildNts _hdOcon _hdOinh _hdOinhsOfChildren _hdOnt _hdOo_case _hdOo_cata _hdOo_dovisit _hdOo_newtypes _hdOo_rename _hdOo_sem _hdOo_sig _hdOo_wantvisit _hdOprefix _hdOsyn _hdOsynsOfChildren )
                       ( _tlIdirectDep,_tlIerrors,_tlIgathAltAttrs,_tlIgathRules,_tlIinstDep,_tlIinstVars,_tlIlocVars) =
                           (tl_ _tlOallTypeSigs _tlOallfields _tlOallnts _tlOaltAttrs _tlOattrs _tlOchildInhs _tlOchildNts _tlOcon _tlOinh _tlOinhsOfChildren _tlOnt _tlOo_case _tlOo_cata _tlOo_dovisit _tlOo_newtypes _tlOo_rename _tlOo_sem _tlOo_sig _tlOo_wantvisit _tlOprefix _tlOsyn _tlOsynsOfChildren )
                   in  ( _lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars))) )
sem_Rules_Nil :: T_Rules 
sem_Rules_Nil  =
    (T_Rules (\ _lhsIallTypeSigs
                _lhsIallfields
                _lhsIallnts
                _lhsIaltAttrs
                _lhsIattrs
                _lhsIchildInhs
                _lhsIchildNts
                _lhsIcon
                _lhsIinh
                _lhsIinhsOfChildren
                _lhsInt
                _lhsIo_case
                _lhsIo_cata
                _lhsIo_dovisit
                _lhsIo_newtypes
                _lhsIo_rename
                _lhsIo_sem
                _lhsIo_sig
                _lhsIo_wantvisit
                _lhsIprefix
                _lhsIsyn
                _lhsIsynsOfChildren ->
                  (let _lhsOdirectDep :: (Seq Edge)
                       _lhsOerrors :: (Seq Error)
                       _lhsOgathAltAttrs :: ([AltAttr])
                       _lhsOgathRules :: (Seq CRule)
                       _lhsOinstDep :: (Seq Edge)
                       _lhsOinstVars :: ([Identifier])
                       _lhsOlocVars :: ([Identifier])
                       -- use rule "Order.ag"(line 249, column 33)
                       _lhsOdirectDep =
                           ({-# LINE 249 "Order.ag" #-}
                            Seq.empty
                            {-# LINE 4504 "Order.hs" #-})
                       -- use rule "Order.ag"(line 64, column 70)
                       _lhsOerrors =
                           ({-# LINE 64 "Order.ag" #-}
                            Seq.empty
                            {-# LINE 4509 "Order.hs" #-})
                       -- use rule "Order.ag"(line 150, column 68)
                       _lhsOgathAltAttrs =
                           ({-# LINE 150 "Order.ag" #-}
                            []
                            {-# LINE 4514 "Order.hs" #-})
                       -- use rule "Order.ag"(line 186, column 23)
                       _lhsOgathRules =
                           ({-# LINE 186 "Order.ag" #-}
                            Seq.empty
                            {-# LINE 4519 "Order.hs" #-})
                       -- use rule "Order.ag"(line 292, column 31)
                       _lhsOinstDep =
                           ({-# LINE 292 "Order.ag" #-}
                            Seq.empty
                            {-# LINE 4524 "Order.hs" #-})
                       -- use rule "Order.ag"(line 600, column 86)
                       _lhsOinstVars =
                           ({-# LINE 600 "Order.ag" #-}
                            []
                            {-# LINE 4529 "Order.hs" #-})
                       -- use rule "Order.ag"(line 600, column 48)
                       _lhsOlocVars =
                           ({-# LINE 600 "Order.ag" #-}
                            []
                            {-# LINE 4534 "Order.hs" #-})
                   in  ( _lhsOdirectDep,_lhsOerrors,_lhsOgathAltAttrs,_lhsOgathRules,_lhsOinstDep,_lhsOinstVars,_lhsOlocVars))) )
-- TypeSig -----------------------------------------------------
{-
   visit 0:
      chained attribute:
         typeSigs             : Map Identifier Type
   alternatives:
      alternative TypeSig:
         child name           : {Identifier}
         child tp             : {Type}
-}
-- cata
sem_TypeSig :: TypeSig  ->
               T_TypeSig 
sem_TypeSig (TypeSig _name _tp )  =
    (sem_TypeSig_TypeSig _name _tp )
-- semantic domain
newtype T_TypeSig  = T_TypeSig ((Map Identifier Type) ->
                                ( (Map Identifier Type)))
data Inh_TypeSig  = Inh_TypeSig {typeSigs_Inh_TypeSig :: !((Map Identifier Type))}
data Syn_TypeSig  = Syn_TypeSig {typeSigs_Syn_TypeSig :: !((Map Identifier Type))}
wrap_TypeSig :: T_TypeSig  ->
                Inh_TypeSig  ->
                Syn_TypeSig 
wrap_TypeSig (T_TypeSig sem ) (Inh_TypeSig _lhsItypeSigs )  =
    (let ( _lhsOtypeSigs) =
             (sem _lhsItypeSigs )
     in  (Syn_TypeSig _lhsOtypeSigs ))
sem_TypeSig_TypeSig :: Identifier ->
                       Type ->
                       T_TypeSig 
sem_TypeSig_TypeSig name_ tp_  =
    (T_TypeSig (\ _lhsItypeSigs ->
                    (let _lhsOtypeSigs :: (Map Identifier Type)
                         -- "Order.ag"(line 456, column 13)
                         _lhsOtypeSigs =
                             ({-# LINE 456 "Order.ag" #-}
                              Map.insert name_ tp_ _lhsItypeSigs
                              {-# LINE 4573 "Order.hs" #-})
                     in  ( _lhsOtypeSigs))) )
-- TypeSigs ----------------------------------------------------
{-
   visit 0:
      chained attribute:
         typeSigs             : Map Identifier Type
   alternatives:
      alternative Cons:
         child hd             : TypeSig 
         child tl             : TypeSigs 
      alternative Nil:
-}
-- cata
sem_TypeSigs :: TypeSigs  ->
                T_TypeSigs 
sem_TypeSigs list  =
    (Prelude.foldr sem_TypeSigs_Cons sem_TypeSigs_Nil (Prelude.map sem_TypeSig list) )
-- semantic domain
newtype T_TypeSigs  = T_TypeSigs ((Map Identifier Type) ->
                                  ( (Map Identifier Type)))
data Inh_TypeSigs  = Inh_TypeSigs {typeSigs_Inh_TypeSigs :: !((Map Identifier Type))}
data Syn_TypeSigs  = Syn_TypeSigs {typeSigs_Syn_TypeSigs :: !((Map Identifier Type))}
wrap_TypeSigs :: T_TypeSigs  ->
                 Inh_TypeSigs  ->
                 Syn_TypeSigs 
wrap_TypeSigs (T_TypeSigs sem ) (Inh_TypeSigs _lhsItypeSigs )  =
    (let ( _lhsOtypeSigs) =
             (sem _lhsItypeSigs )
     in  (Syn_TypeSigs _lhsOtypeSigs ))
sem_TypeSigs_Cons :: T_TypeSig  ->
                     T_TypeSigs  ->
                     T_TypeSigs 
sem_TypeSigs_Cons (T_TypeSig hd_ ) (T_TypeSigs tl_ )  =
    (T_TypeSigs (\ _lhsItypeSigs ->
                     (let _lhsOtypeSigs :: (Map Identifier Type)
                          _hdOtypeSigs :: (Map Identifier Type)
                          _tlOtypeSigs :: (Map Identifier Type)
                          _hdItypeSigs :: (Map Identifier Type)
                          _tlItypeSigs :: (Map Identifier Type)
                          -- copy rule (up)
                          _lhsOtypeSigs =
                              ({-# LINE 452 "Order.ag" #-}
                               _tlItypeSigs
                               {-# LINE 4617 "Order.hs" #-})
                          -- copy rule (down)
                          _hdOtypeSigs =
                              ({-# LINE 452 "Order.ag" #-}
                               _lhsItypeSigs
                               {-# LINE 4622 "Order.hs" #-})
                          -- copy rule (chain)
                          _tlOtypeSigs =
                              ({-# LINE 452 "Order.ag" #-}
                               _hdItypeSigs
                               {-# LINE 4627 "Order.hs" #-})
                          ( _hdItypeSigs) =
                              (hd_ _hdOtypeSigs )
                          ( _tlItypeSigs) =
                              (tl_ _tlOtypeSigs )
                      in  ( _lhsOtypeSigs))) )
sem_TypeSigs_Nil :: T_TypeSigs 
sem_TypeSigs_Nil  =
    (T_TypeSigs (\ _lhsItypeSigs ->
                     (let _lhsOtypeSigs :: (Map Identifier Type)
                          -- copy rule (chain)
                          _lhsOtypeSigs =
                              ({-# LINE 452 "Order.ag" #-}
                               _lhsItypeSigs
                               {-# LINE 4641 "Order.hs" #-})
                      in  ( _lhsOtypeSigs))) )