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

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

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

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

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

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

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

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

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

{-# LINE 14 "src-ag/Desugar.ag" #-}

import qualified Data.Set as Set
import qualified Data.Map as Map
import Data.Map(Map)
import qualified Data.Sequence as Seq
import Data.Sequence(Seq,(><))
import UU.Scanner.Position(Pos(..))
import Data.Maybe
import Data.List(intersperse)

import AbstractSyntax
import ErrorMessages
import Options
import HsToken
import HsTokenScanner
import TokenDef
import CommonTypes
{-# LINE 56 "src-generated/Desugar.hs" #-}
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity
{-# LINE 98 "src-ag/Desugar.ag" #-}

addl :: Int -> Pos -> Pos
addl n (Pos l c f) = Pos (l+n) c f
{-# LINE 63 "src-generated/Desugar.hs" #-}

{-# LINE 133 "src-ag/Desugar.ag" #-}

maybeError :: a -> Error -> Maybe a -> (a, Seq Error)
maybeError def err mb
  = maybe (def, Seq.singleton err) (\r -> (r, Seq.empty)) mb

findField :: Identifier -> Identifier -> [(Identifier,Identifier)] -> Maybe Identifier
findField fld attr list
  | fld == _FIRST = f list
  | fld == _LAST  = f (reverse list)
  | otherwise     = Just fld
  where
    f = lookup attr
{-# LINE 78 "src-generated/Desugar.hs" #-}

{-# LINE 204 "src-ag/Desugar.ag" #-}

mergeAttributes :: AttrMap -> AttrMap -> AttrMap
mergeAttributes = Map.unionWith $ Map.unionWith $ Set.union
{-# LINE 84 "src-generated/Desugar.hs" #-}

{-# LINE 251 "src-ag/Desugar.ag" #-}

desugarExprs :: Options -> NontermIdent -> ConstructorIdent ->
                [(Identifier, Identifier)] -> [(Identifier, Identifier)] ->
                Seq Error -> [Expression] -> (Seq Error, [Expression])
desugarExprs options nt con childInhs childSyns
  = mapAccum (desugarExpr options nt con childInhs childSyns)
  where mapAccum f e = foldr (\x (e0,xs) -> let (e1,x') = f e0 x in (e1, x:xs)) (e, [])

desugarExpr :: Options -> NontermIdent -> ConstructorIdent ->
               [(Identifier, Identifier)] -> [(Identifier, Identifier)] ->
               Seq Error -> Expression -> (Seq Error, Expression)
desugarExpr options nt con childInhs childSyns errs expr
  = (errs Seq.>< errors_Syn_Expression syn, output_Syn_Expression syn)
  where
    inh = Inh_Expression { childInhs_Inh_Expression = childInhs
                         , childSyns_Inh_Expression = childSyns
                         , con_Inh_Expression       = con
                         , nt_Inh_Expression        = nt
                         , options_Inh_Expression   = options
                         , ruleDescr_Inh_Expression = "augment-rule"
                         }
    sem = sem_Expression expr
    syn = wrap_Expression sem inh
{-# LINE 110 "src-generated/Desugar.hs" #-}

{-# LINE 294 "src-ag/Desugar.ag" #-}

addLateAttr :: Options -> String -> Attributes
addLateAttr options mainName
  | kennedyWarren options && lateHigherOrderBinding options =
      let tp = lateBindingType mainName
      in Map.singleton idLateBindingAttr tp
  | otherwise = Map.empty
{-# LINE 120 "src-generated/Desugar.hs" #-}
-- Child -------------------------------------------------------
-- wrapper
data Inh_Child  = Inh_Child { Inh_Child -> Map NontermIdent Attributes
inhMap_Inh_Child :: !(Map Identifier Attributes), Inh_Child -> String
mainName_Inh_Child :: !(String), Inh_Child -> Options
options_Inh_Child :: !(Options), Inh_Child -> Map NontermIdent Attributes
synMap_Inh_Child :: !(Map Identifier Attributes) }
data Syn_Child  = Syn_Child { Syn_Child -> [(NontermIdent, NontermIdent)]
childInhs_Syn_Child :: !([(Identifier, Identifier)]), Syn_Child -> [(NontermIdent, NontermIdent)]
childSyns_Syn_Child :: !([(Identifier, Identifier)]), Syn_Child -> Child
output_Syn_Child :: !(Child) }
{-# INLINABLE wrap_Child #-}
wrap_Child :: T_Child  -> Inh_Child  -> (Syn_Child )
wrap_Child :: T_Child -> Inh_Child -> Syn_Child
wrap_Child !(T_Child Identity T_Child_s0
act) !(Inh_Child Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Child_s0
sem <- Identity T_Child_s0
act
        let arg0 :: T_Child_vIn0
arg0 = Map NontermIdent Attributes
-> String -> Options -> Map NontermIdent Attributes -> T_Child_vIn0
T_Child_vIn0 Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap
        !(T_Child_vOut0 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Child
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Child_s0 -> forall t. K_Child_s0 t -> t
inv_Child_s0 T_Child_s0
sem K_Child_s0 T_Child_v0
K_Child_v0 T_Child_vIn0
arg0)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Child -> Syn_Child
Syn_Child [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Child
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Child  = T_Child {
                           T_Child -> Identity T_Child_s0
attach_T_Child :: Identity (T_Child_s0 )
                           }
data T_Child_s0  where C_Child_s0 :: {
                                     T_Child_s0 -> forall t. K_Child_s0 t -> t
inv_Child_s0 :: !(forall t. K_Child_s0  t -> t)
                                     } -> T_Child_s0 
data T_Child_s1  = C_Child_s1
data T_Child_s34  = C_Child_s34
data K_Child_s0 k  where
   K_Child_v0 :: K_Child_s0  (T_Child_v0 )
   K_Child_v17 :: K_Child_s0  (T_Child_v17 )
type T_Child_v0  = (T_Child_vIn0 ) -> (T_Child_vOut0 )
data T_Child_vIn0  = T_Child_vIn0 !(Map Identifier Attributes) !(String) !(Options) !(Map Identifier Attributes)
data T_Child_vOut0  = T_Child_vOut0 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(Child)
type T_Child_v17  = (T_Child_vIn17 ) -> (T_Child_vOut17 )
data T_Child_vIn17  = T_Child_vIn17 !(Map Identifier Attributes) !(Map Identifier Attributes)
data T_Child_vOut17  = T_Child_vOut17 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(Child)
{-# NOINLINE sem_Child_Child #-}
sem_Child_Child :: (Identifier) -> (Type) -> (ChildKind) -> T_Child 
sem_Child_Child :: NontermIdent -> Type -> ChildKind -> T_Child
sem_Child_Child !NontermIdent
arg_name_ !Type
arg_tp_ !ChildKind
arg_kind_ = Identity T_Child_s0 -> T_Child
T_Child (forall (m :: * -> *) a. Monad m => a -> m a
return T_Child_s0
st0) where
   {-# NOINLINE st0 #-}
   !st0 :: T_Child_s0
st0 = let
      k0 :: K_Child_s0  t -> t
      k0 :: forall t. K_Child_s0 t -> t
k0 K_Child_s0 t
K_Child_v0 = T_Child_v0
v0
      k0 K_Child_s0 t
K_Child_v17 = T_Child_vIn17 -> T_Child_vOut17
v17
      v0 :: T_Child_v0 
      v0 :: T_Child_v0
v0 = \ !(T_Child_vIn0 Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_chnt :: NontermIdent
_chnt = NontermIdent -> Type -> NontermIdent
rule0 NontermIdent
arg_name_ Type
arg_tp_ in
         let !_inh :: Attributes
_inh = NontermIdent -> Map NontermIdent Attributes -> Attributes
rule1 NontermIdent
_chnt Map NontermIdent Attributes
_lhsIinhMap in
         let _lhsOchildInhs :: [(Identifier, Identifier)]
             !_lhsOchildInhs :: [(NontermIdent, NontermIdent)]
_lhsOchildInhs = forall {a} {a} {b}. Map a a -> b -> [(a, b)]
rule3 Attributes
_inh NontermIdent
arg_name_ in
         let !_syn :: Attributes
_syn = NontermIdent -> Map NontermIdent Attributes -> Attributes
rule2 NontermIdent
_chnt Map NontermIdent Attributes
_lhsIsynMap in
         let _lhsOchildSyns :: [(Identifier, Identifier)]
             !_lhsOchildSyns :: [(NontermIdent, NontermIdent)]
_lhsOchildSyns = forall {a} {a} {b}. Map a a -> b -> [(a, b)]
rule4 Attributes
_syn NontermIdent
arg_name_ in
         let _lhsOoutput :: Child
             !_lhsOoutput :: Child
_lhsOoutput = ChildKind -> NontermIdent -> Type -> Child
rule5 ChildKind
arg_kind_ NontermIdent
arg_name_ Type
arg_tp_ in
         let !__result_ :: T_Child_vOut0
__result_ = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Child -> T_Child_vOut0
T_Child_vOut0 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Child
_lhsOoutput
          in T_Child_vOut0
__result_ )
      v17 :: T_Child_v17 
      v17 :: T_Child_vIn17 -> T_Child_vOut17
v17 = \ !(T_Child_vIn17 Map NontermIdent Attributes
_lhsIinhMap Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_chnt :: NontermIdent
_chnt = NontermIdent -> Type -> NontermIdent
rule0 NontermIdent
arg_name_ Type
arg_tp_ in
         let !_inh :: Attributes
_inh = NontermIdent -> Map NontermIdent Attributes -> Attributes
rule1 NontermIdent
_chnt Map NontermIdent Attributes
_lhsIinhMap in
         let _lhsOchildInhs :: [(Identifier, Identifier)]
             !_lhsOchildInhs :: [(NontermIdent, NontermIdent)]
_lhsOchildInhs = forall {a} {a} {b}. Map a a -> b -> [(a, b)]
rule3 Attributes
_inh NontermIdent
arg_name_ in
         let !_syn :: Attributes
_syn = NontermIdent -> Map NontermIdent Attributes -> Attributes
rule2 NontermIdent
_chnt Map NontermIdent Attributes
_lhsIsynMap in
         let _lhsOchildSyns :: [(Identifier, Identifier)]
             !_lhsOchildSyns :: [(NontermIdent, NontermIdent)]
_lhsOchildSyns = forall {a} {a} {b}. Map a a -> b -> [(a, b)]
rule4 Attributes
_syn NontermIdent
arg_name_ in
         let _lhsOoutput :: Child
             !_lhsOoutput :: Child
_lhsOoutput = ChildKind -> NontermIdent -> Type -> Child
rule5 ChildKind
arg_kind_ NontermIdent
arg_name_ Type
arg_tp_ in
         let !__result_ :: T_Child_vOut17
__result_ = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Child -> T_Child_vOut17
T_Child_vOut17 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Child
_lhsOoutput
          in T_Child_vOut17
__result_ )
     in (forall t. K_Child_s0 t -> t) -> T_Child_s0
C_Child_s0 forall t. K_Child_s0 t -> t
k0
   {-# NOINLINE[1] rule0 #-}
   {-# LINE 19 "src-ag/DistChildAttr.ag" #-}
   rule0 = \ !name_ !tp_ ->
                       {-# LINE 19 "src-ag/DistChildAttr.ag" #-}
                       case tp_ of
                         NT nt _ _ -> nt
                         Self      -> error ("The type of child " ++ show name_ ++ " should not be a Self type.")
                         Haskell t -> identifier ""
                       {-# LINE 201 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule1 #-}
   {-# LINE 23 "src-ag/DistChildAttr.ag" #-}
   rule1 = \ !_chnt ((!_lhsIinhMap) :: Map Identifier Attributes) ->
                      {-# LINE 23 "src-ag/DistChildAttr.ag" #-}
                      Map.findWithDefault Map.empty _chnt     _lhsIinhMap
                      {-# LINE 207 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule2 #-}
   {-# LINE 24 "src-ag/DistChildAttr.ag" #-}
   rule2 = \ !_chnt ((!_lhsIsynMap) :: Map Identifier Attributes) ->
                      {-# LINE 24 "src-ag/DistChildAttr.ag" #-}
                      Map.findWithDefault Map.empty _chnt     _lhsIsynMap
                      {-# LINE 213 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule3 #-}
   {-# LINE 130 "src-ag/Desugar.ag" #-}
   rule3 = \ !_inh !name_ ->
                        {-# LINE 130 "src-ag/Desugar.ag" #-}
                        [(i, name_) | i <- Map.keys _inh     ]
                        {-# LINE 219 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule4 #-}
   {-# LINE 131 "src-ag/Desugar.ag" #-}
   rule4 = \ !_syn !name_ ->
                        {-# LINE 131 "src-ag/Desugar.ag" #-}
                        [(s, name_) | s <- Map.keys _syn     ]
                        {-# LINE 225 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule5 #-}
   {-# LINE 315 "src-ag/Desugar.ag" #-}
   rule5 = \ !kind_ !name_ !tp_ ->
                 {-# LINE 315 "src-ag/Desugar.ag" #-}
                 Child name_ tp_ kind_
                 {-# LINE 231 "src-generated/Desugar.hs" #-}

-- Children ----------------------------------------------------
-- wrapper
data Inh_Children  = Inh_Children { Inh_Children -> Map NontermIdent Attributes
inhMap_Inh_Children :: !(Map Identifier Attributes), Inh_Children -> String
mainName_Inh_Children :: !(String), Inh_Children -> Options
options_Inh_Children :: !(Options), Inh_Children -> Map NontermIdent Attributes
synMap_Inh_Children :: !(Map Identifier Attributes) }
data Syn_Children  = Syn_Children { Syn_Children -> [(NontermIdent, NontermIdent)]
childInhs_Syn_Children :: !([(Identifier, Identifier)]), Syn_Children -> [(NontermIdent, NontermIdent)]
childSyns_Syn_Children :: !([(Identifier, Identifier)]), Syn_Children -> Children
output_Syn_Children :: !(Children) }
{-# INLINABLE wrap_Children #-}
wrap_Children :: T_Children  -> Inh_Children  -> (Syn_Children )
wrap_Children :: T_Children -> Inh_Children -> Syn_Children
wrap_Children !(T_Children Identity T_Children_s2
act) !(Inh_Children Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Children_s2
sem <- Identity T_Children_s2
act
        let arg1 :: T_Children_vIn1
arg1 = Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Children_vIn1
T_Children_vIn1 Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap
        !(T_Children_vOut1 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Children
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 T_Children_s2
sem K_Children_s2 T_Children_v1
K_Children_v1 T_Children_vIn1
arg1)
        forall (m :: * -> *) a. Monad m => a -> m a
return ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Children -> Syn_Children
Syn_Children [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Children
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Children  = T_Children {
                                 T_Children -> Identity T_Children_s2
attach_T_Children :: Identity (T_Children_s2 )
                                 }
data T_Children_s2  where C_Children_s2 :: {
                                           T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 :: !(forall t. K_Children_s2  t -> t)
                                           } -> T_Children_s2 
data T_Children_s3  = C_Children_s3
data T_Children_s35  = C_Children_s35
data K_Children_s2 k  where
   K_Children_v1 :: K_Children_s2  (T_Children_v1 )
   K_Children_v18 :: K_Children_s2  (T_Children_v18 )
type T_Children_v1  = (T_Children_vIn1 ) -> (T_Children_vOut1 )
data T_Children_vIn1  = T_Children_vIn1 !(Map Identifier Attributes) !(String) !(Options) !(Map Identifier Attributes)
data T_Children_vOut1  = T_Children_vOut1 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(Children)
type T_Children_v18  = (T_Children_vIn18 ) -> (T_Children_vOut18 )
data T_Children_vIn18  = T_Children_vIn18 !(Map Identifier Attributes) !(Map Identifier Attributes)
data T_Children_vOut18  = T_Children_vOut18 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(Children)
{-# NOINLINE sem_Children_Cons #-}
sem_Children_Cons :: T_Child  -> T_Children  -> T_Children 
sem_Children_Cons :: T_Child -> T_Children -> T_Children
sem_Children_Cons T_Child
arg_hd_ T_Children
arg_tl_ = Identity T_Children_s2 -> T_Children
T_Children (forall (m :: * -> *) a. Monad m => a -> m a
return T_Children_s2
st2) where
   {-# NOINLINE st2 #-}
   !st2 :: T_Children_s2
st2 = let
      k2 :: K_Children_s2  t -> t
      k2 :: forall t. K_Children_s2 t -> t
k2 K_Children_s2 t
K_Children_v1 = T_Children_v1
v1
      k2 K_Children_s2 t
K_Children_v18 = T_Children_vIn18 -> T_Children_vOut18
v18
      v1 :: T_Children_v1 
      v1 :: T_Children_v1
v1 = \ !(T_Children_vIn1 Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdX0 :: T_Child_s0
_hdX0 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Child -> Identity T_Child_s0
attach_T_Child (T_Child
arg_hd_)) in
         let !_tlX2 :: T_Children_s2
_tlX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s2
attach_T_Children (T_Children
arg_tl_)) in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule11 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule15 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule14 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule18 Map NontermIdent Attributes
_lhsIsynMap in
         let !(T_Child_vOut17 [(NontermIdent, NontermIdent)]
_hdIchildInhs [(NontermIdent, NontermIdent)]
_hdIchildSyns Child
_hdIoutput) = T_Child_s0 -> forall t. K_Child_s0 t -> t
inv_Child_s0 T_Child_s0
_hdX0 K_Child_s0 (T_Child_vIn17 -> T_Child_vOut17)
K_Child_v17 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Child_vIn17
T_Child_vIn17 Map NontermIdent Attributes
_hdOinhMap Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Children_vOut18 [(NontermIdent, NontermIdent)]
_tlIchildInhs [(NontermIdent, NontermIdent)]
_tlIchildSyns Children
_tlIoutput) = T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 T_Children_s2
_tlX2 K_Children_s2 (T_Children_vIn18 -> T_Children_vOut18)
K_Children_v18 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Children_vIn18
T_Children_vIn18 Map NontermIdent Attributes
_tlOinhMap Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOchildInhs :: [(Identifier, Identifier)]
             !_lhsOchildInhs :: [(NontermIdent, NontermIdent)]
_lhsOchildInhs = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule7 [(NontermIdent, NontermIdent)]
_hdIchildInhs [(NontermIdent, NontermIdent)]
_tlIchildInhs in
         let _lhsOchildSyns :: [(Identifier, Identifier)]
             !_lhsOchildSyns :: [(NontermIdent, NontermIdent)]
_lhsOchildSyns = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule8 [(NontermIdent, NontermIdent)]
_hdIchildSyns [(NontermIdent, NontermIdent)]
_tlIchildSyns in
         let !_output :: Children
_output = Child -> Children -> Children
rule9 Child
_hdIoutput Children
_tlIoutput in
         let _lhsOoutput :: Children
             !_lhsOoutput :: Children
_lhsOoutput = forall a. a -> a
rule10 Children
_output in
         let !__result_ :: T_Children_vOut1
__result_ = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Children -> T_Children_vOut1
T_Children_vOut1 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Children
_lhsOoutput
          in T_Children_vOut1
__result_ )
      v18 :: T_Children_v18 
      v18 :: T_Children_vIn18 -> T_Children_vOut18
v18 = \ !(T_Children_vIn18 Map NontermIdent Attributes
_lhsIinhMap Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdX0 :: T_Child_s0
_hdX0 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Child -> Identity T_Child_s0
attach_T_Child (T_Child
arg_hd_)) in
         let !_tlX2 :: T_Children_s2
_tlX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s2
attach_T_Children (T_Children
arg_tl_)) in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule11 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule15 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule14 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule18 Map NontermIdent Attributes
_lhsIsynMap in
         let !(T_Child_vOut17 [(NontermIdent, NontermIdent)]
_hdIchildInhs [(NontermIdent, NontermIdent)]
_hdIchildSyns Child
_hdIoutput) = T_Child_s0 -> forall t. K_Child_s0 t -> t
inv_Child_s0 T_Child_s0
_hdX0 K_Child_s0 (T_Child_vIn17 -> T_Child_vOut17)
K_Child_v17 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Child_vIn17
T_Child_vIn17 Map NontermIdent Attributes
_hdOinhMap Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Children_vOut18 [(NontermIdent, NontermIdent)]
_tlIchildInhs [(NontermIdent, NontermIdent)]
_tlIchildSyns Children
_tlIoutput) = T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 T_Children_s2
_tlX2 K_Children_s2 (T_Children_vIn18 -> T_Children_vOut18)
K_Children_v18 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Children_vIn18
T_Children_vIn18 Map NontermIdent Attributes
_tlOinhMap Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOchildInhs :: [(Identifier, Identifier)]
             !_lhsOchildInhs :: [(NontermIdent, NontermIdent)]
_lhsOchildInhs = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule7 [(NontermIdent, NontermIdent)]
_hdIchildInhs [(NontermIdent, NontermIdent)]
_tlIchildInhs in
         let _lhsOchildSyns :: [(Identifier, Identifier)]
             !_lhsOchildSyns :: [(NontermIdent, NontermIdent)]
_lhsOchildSyns = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule8 [(NontermIdent, NontermIdent)]
_hdIchildSyns [(NontermIdent, NontermIdent)]
_tlIchildSyns in
         let !_output :: Children
_output = Child -> Children -> Children
rule9 Child
_hdIoutput Children
_tlIoutput in
         let _lhsOoutput :: Children
             !_lhsOoutput :: Children
_lhsOoutput = forall a. a -> a
rule10 Children
_output in
         let !__result_ :: T_Children_vOut18
__result_ = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Children -> T_Children_vOut18
T_Children_vOut18 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Children
_lhsOoutput
          in T_Children_vOut18
__result_ )
     in (forall t. K_Children_s2 t -> t) -> T_Children_s2
C_Children_s2 forall t. K_Children_s2 t -> t
k2
   {-# NOINLINE[1] rule7 #-}
   rule7 :: [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule7 = \ ((![(NontermIdent, NontermIdent)]
_hdIchildInhs) :: [(Identifier, Identifier)]) ((![(NontermIdent, NontermIdent)]
_tlIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_hdIchildInhs forall a. [a] -> [a] -> [a]
++ [(NontermIdent, NontermIdent)]
_tlIchildInhs
   {-# NOINLINE[1] rule8 #-}
   rule8 :: [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule8 = \ ((![(NontermIdent, NontermIdent)]
_hdIchildSyns) :: [(Identifier, Identifier)]) ((![(NontermIdent, NontermIdent)]
_tlIchildSyns) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_hdIchildSyns forall a. [a] -> [a] -> [a]
++ [(NontermIdent, NontermIdent)]
_tlIchildSyns
   {-# NOINLINE[1] rule9 #-}
   rule9 :: Child -> Children -> Children
rule9 = \ ((!Child
_hdIoutput) :: Child) ((!Children
_tlIoutput) :: Children) ->
     (:) Child
_hdIoutput Children
_tlIoutput
   {-# NOINLINE[1] rule10 #-}
   rule10 :: p -> p
rule10 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule11 #-}
   rule11 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule11 = \ ((!Map NontermIdent Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIinhMap
   {-# NOINLINE[1] rule14 #-}
   rule14 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule14 = \ ((!Map NontermIdent Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIsynMap
   {-# NOINLINE[1] rule15 #-}
   rule15 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule15 = \ ((!Map NontermIdent Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIinhMap
   {-# NOINLINE[1] rule18 #-}
   rule18 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule18 = \ ((!Map NontermIdent Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIsynMap
{-# NOINLINE sem_Children_Nil #-}
sem_Children_Nil ::  T_Children 
sem_Children_Nil :: T_Children
sem_Children_Nil  = Identity T_Children_s2 -> T_Children
T_Children (forall (m :: * -> *) a. Monad m => a -> m a
return T_Children_s2
st2) where
   {-# NOINLINE st2 #-}
   !st2 :: T_Children_s2
st2 = let
      k2 :: K_Children_s2  t -> t
      k2 :: forall t. K_Children_s2 t -> t
k2 K_Children_s2 t
K_Children_v1 = T_Children_v1
v1
      k2 K_Children_s2 t
K_Children_v18 = T_Children_vIn18 -> T_Children_vOut18
v18
      v1 :: T_Children_v1 
      v1 :: T_Children_v1
v1 = \ !(T_Children_vIn1 Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOchildInhs :: [(Identifier, Identifier)]
             !_lhsOchildInhs :: [(NontermIdent, NontermIdent)]
_lhsOchildInhs = forall {a}. () -> [a]
rule19  () in
         let _lhsOchildSyns :: [(Identifier, Identifier)]
             !_lhsOchildSyns :: [(NontermIdent, NontermIdent)]
_lhsOchildSyns = forall {a}. () -> [a]
rule20  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule21  () in
         let _lhsOoutput :: Children
             !_lhsOoutput :: Children
_lhsOoutput = forall a. a -> a
rule22 forall a. [a]
_output in
         let !__result_ :: T_Children_vOut1
__result_ = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Children -> T_Children_vOut1
T_Children_vOut1 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Children
_lhsOoutput
          in T_Children_vOut1
__result_ )
      v18 :: T_Children_v18 
      v18 :: T_Children_vIn18 -> T_Children_vOut18
v18 = \ !(T_Children_vIn18 Map NontermIdent Attributes
_lhsIinhMap Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOchildInhs :: [(Identifier, Identifier)]
             !_lhsOchildInhs :: [(NontermIdent, NontermIdent)]
_lhsOchildInhs = forall {a}. () -> [a]
rule19  () in
         let _lhsOchildSyns :: [(Identifier, Identifier)]
             !_lhsOchildSyns :: [(NontermIdent, NontermIdent)]
_lhsOchildSyns = forall {a}. () -> [a]
rule20  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule21  () in
         let _lhsOoutput :: Children
             !_lhsOoutput :: Children
_lhsOoutput = forall a. a -> a
rule22 forall a. [a]
_output in
         let !__result_ :: T_Children_vOut18
__result_ = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)] -> Children -> T_Children_vOut18
T_Children_vOut18 [(NontermIdent, NontermIdent)]
_lhsOchildInhs [(NontermIdent, NontermIdent)]
_lhsOchildSyns Children
_lhsOoutput
          in T_Children_vOut18
__result_ )
     in (forall t. K_Children_s2 t -> t) -> T_Children_s2
C_Children_s2 forall t. K_Children_s2 t -> t
k2
   {-# NOINLINE[1] rule19 #-}
   rule19 :: () -> [a]
rule19 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule20 #-}
   rule20 :: () -> [a]
rule20 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule21 #-}
   rule21 :: () -> [a]
rule21 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule22 #-}
   rule22 :: p -> p
rule22 = \ !p
_output ->
     p
_output

-- Expression --------------------------------------------------
-- wrapper
data Inh_Expression  = Inh_Expression { Inh_Expression -> [(NontermIdent, NontermIdent)]
childInhs_Inh_Expression :: !([(Identifier, Identifier)]), Inh_Expression -> [(NontermIdent, NontermIdent)]
childSyns_Inh_Expression :: !([(Identifier, Identifier)]), Inh_Expression -> NontermIdent
con_Inh_Expression :: !(ConstructorIdent), Inh_Expression -> NontermIdent
nt_Inh_Expression :: !(NontermIdent), Inh_Expression -> Options
options_Inh_Expression :: !(Options), Inh_Expression -> String
ruleDescr_Inh_Expression :: !(String) }
data Syn_Expression  = Syn_Expression { Syn_Expression -> Seq Error
errors_Syn_Expression :: !(Seq Error), Syn_Expression -> Expression
output_Syn_Expression :: !(Expression) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression  -> Inh_Expression  -> (Syn_Expression )
wrap_Expression :: T_Expression -> Inh_Expression -> Syn_Expression
wrap_Expression !(T_Expression Identity T_Expression_s4
act) !(Inh_Expression [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt Options
_lhsIoptions String
_lhsIruleDescr) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Expression_s4
sem <- Identity T_Expression_s4
act
        let arg2 :: T_Expression_vIn2
arg2 = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> Options
-> String
-> T_Expression_vIn2
T_Expression_vIn2 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt Options
_lhsIoptions String
_lhsIruleDescr
        !(T_Expression_vOut2 Seq Error
_lhsOerrors Expression
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Expression_s4 -> T_Expression_v2
inv_Expression_s4 T_Expression_s4
sem T_Expression_vIn2
arg2)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Seq Error -> Expression -> Syn_Expression
Syn_Expression Seq Error
_lhsOerrors Expression
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Expression  = T_Expression {
                                     T_Expression -> Identity T_Expression_s4
attach_T_Expression :: Identity (T_Expression_s4 )
                                     }
newtype T_Expression_s4  = C_Expression_s4 {
                                           T_Expression_s4 -> T_Expression_v2
inv_Expression_s4 :: (T_Expression_v2 )
                                           }
data T_Expression_s5  = C_Expression_s5
type T_Expression_v2  = (T_Expression_vIn2 ) -> (T_Expression_vOut2 )
data T_Expression_vIn2  = T_Expression_vIn2 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent) !(Options) !(String)
data T_Expression_vOut2  = T_Expression_vOut2 !(Seq Error) !(Expression)
{-# NOINLINE sem_Expression_Expression #-}
sem_Expression_Expression :: (Pos) -> ([HsToken]) -> T_Expression 
sem_Expression_Expression :: Pos -> HsTokens -> T_Expression
sem_Expression_Expression !Pos
arg_pos_ !HsTokens
arg_tks_ = Identity T_Expression_s4 -> T_Expression
T_Expression (forall (m :: * -> *) a. Monad m => a -> m a
return T_Expression_s4
st4) where
   {-# NOINLINE st4 #-}
   !st4 :: T_Expression_s4
st4 = let
      v2 :: T_Expression_v2 
      v2 :: T_Expression_v2
v2 = \ !(T_Expression_vIn2 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt Options
_lhsIoptions String
_lhsIruleDescr) -> (
         let _lhsOerrors :: Seq Error
             !(!HsTokens
_tks',!Seq Error
_lhsOerrors) = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> Options
-> String
-> HsTokens
-> (HsTokens, Seq Error)
rule23 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt Options
_lhsIoptions String
_lhsIruleDescr HsTokens
arg_tks_ in
         let _lhsOoutput :: Expression
             !_lhsOoutput :: Expression
_lhsOoutput = HsTokens -> Pos -> Expression
rule24 HsTokens
_tks' Pos
arg_pos_ in
         let !__result_ :: T_Expression_vOut2
__result_ = Seq Error -> Expression -> T_Expression_vOut2
T_Expression_vOut2 Seq Error
_lhsOerrors Expression
_lhsOoutput
          in T_Expression_vOut2
__result_ )
     in T_Expression_v2 -> T_Expression_s4
C_Expression_s4 T_Expression_v2
v2
   {-# INLINE rule23 #-}
   {-# LINE 49 "src-ag/Desugar.ag" #-}
   rule23 = \ ((!_lhsIchildInhs) :: [(Identifier, Identifier)]) ((!_lhsIchildSyns) :: [(Identifier, Identifier)]) ((!_lhsIcon) :: ConstructorIdent) ((!_lhsInt) :: NontermIdent) ((!_lhsIoptions) :: Options) ((!_lhsIruleDescr) :: String) !tks_ ->
                                 {-# LINE 49 "src-ag/Desugar.ag" #-}
                                 let inh = Inh_HsTokensRoot { childInhs_Inh_HsTokensRoot     = _lhsIchildInhs
                                                            , childSyns_Inh_HsTokensRoot     = _lhsIchildSyns
                                                            , nt_Inh_HsTokensRoot            = _lhsInt
                                                            , con_Inh_HsTokensRoot           = _lhsIcon
                                                            , ruleDescr_Inh_HsTokensRoot     = _lhsIruleDescr
                                                            , useFieldIdent_Inh_HsTokensRoot = genUseTraces _lhsIoptions
                                                            }
                                     sem = sem_HsTokensRoot (HsTokensRoot tks_)
                                     syn = wrap_HsTokensRoot sem inh
                                 in (tks_Syn_HsTokensRoot syn, errors_Syn_HsTokensRoot syn)
                                 {-# LINE 443 "src-generated/Desugar.hs" #-}
   {-# INLINE rule24 #-}
   {-# LINE 59 "src-ag/Desugar.ag" #-}
   rule24 = \ !_tks' !pos_ ->
                     {-# LINE 59 "src-ag/Desugar.ag" #-}
                     Expression pos_ _tks'
                     {-# LINE 449 "src-generated/Desugar.hs" #-}

-- Grammar -----------------------------------------------------
-- wrapper
data Inh_Grammar  = Inh_Grammar { Inh_Grammar -> AttrMap
forcedIrrefutables_Inh_Grammar :: !(AttrMap), Inh_Grammar -> String
mainName_Inh_Grammar :: !(String), Inh_Grammar -> Options
options_Inh_Grammar :: !(Options) }
data Syn_Grammar  = Syn_Grammar { Syn_Grammar -> AttrMap
allAttributes_Syn_Grammar :: !(AttrMap), Syn_Grammar -> Seq Error
errors_Syn_Grammar :: !(Seq Error), Syn_Grammar -> Grammar
output_Syn_Grammar :: !(Grammar) }
{-# INLINABLE wrap_Grammar #-}
wrap_Grammar :: T_Grammar  -> Inh_Grammar  -> (Syn_Grammar )
wrap_Grammar :: T_Grammar -> Inh_Grammar -> Syn_Grammar
wrap_Grammar !(T_Grammar Identity T_Grammar_s6
act) !(Inh_Grammar AttrMap
_lhsIforcedIrrefutables String
_lhsImainName Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Grammar_s6
sem <- Identity T_Grammar_s6
act
        let arg3 :: T_Grammar_vIn3
arg3 = AttrMap -> String -> Options -> T_Grammar_vIn3
T_Grammar_vIn3 AttrMap
_lhsIforcedIrrefutables String
_lhsImainName Options
_lhsIoptions
        !(T_Grammar_vOut3 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Grammar
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Grammar_s6 -> T_Grammar_v3
inv_Grammar_s6 T_Grammar_s6
sem T_Grammar_vIn3
arg3)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap -> Seq Error -> Grammar -> Syn_Grammar
Syn_Grammar AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Grammar
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Grammar  = T_Grammar {
                               T_Grammar -> Identity T_Grammar_s6
attach_T_Grammar :: Identity (T_Grammar_s6 )
                               }
newtype T_Grammar_s6  = C_Grammar_s6 {
                                     T_Grammar_s6 -> T_Grammar_v3
inv_Grammar_s6 :: (T_Grammar_v3 )
                                     }
data T_Grammar_s7  = C_Grammar_s7
type T_Grammar_v3  = (T_Grammar_vIn3 ) -> (T_Grammar_vOut3 )
data T_Grammar_vIn3  = T_Grammar_vIn3 !(AttrMap) !(String) !(Options)
data T_Grammar_vOut3  = T_Grammar_vOut3 !(AttrMap) !(Seq Error) !(Grammar)
{-# NOINLINE sem_Grammar_Grammar #-}
sem_Grammar_Grammar :: (TypeSyns) -> (UseMap) -> (Derivings) -> (Set NontermIdent) -> T_Nonterminals  -> (PragmaMap) -> (AttrOrderMap) -> (ParamMap) -> (ContextMap) -> (QuantMap) -> (UniqueMap) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) -> (Map NontermIdent (Map ConstructorIdent (Map Identifier (Identifier, [Identifier], Expression)))) -> T_Grammar 
sem_Grammar_Grammar :: TypeSyns
-> UseMap
-> Derivings
-> Set NontermIdent
-> T_Nonterminals
-> PragmaMap
-> AttrOrderMap
-> ParamMap
-> ContextMap
-> QuantMap
-> UniqueMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> T_Grammar
sem_Grammar_Grammar !TypeSyns
arg_typeSyns_ !UseMap
arg_useMap_ !Derivings
arg_derivings_ !Set NontermIdent
arg_wrappers_ T_Nonterminals
arg_nonts_ !PragmaMap
arg_pragmas_ !AttrOrderMap
arg_manualAttrOrderMap_ !ParamMap
arg_paramMap_ !ContextMap
arg_contextMap_ !QuantMap
arg_quantMap_ !UniqueMap
arg_uniqueMap_ !Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_augmentsMap_ !Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_aroundsMap_ !Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
arg_mergeMap_ = Identity T_Grammar_s6 -> T_Grammar
T_Grammar (forall (m :: * -> *) a. Monad m => a -> m a
return T_Grammar_s6
st6) where
   {-# NOINLINE st6 #-}
   !st6 :: T_Grammar_s6
st6 = let
      v3 :: T_Grammar_v3 
      v3 :: T_Grammar_v3
v3 = \ !(T_Grammar_vIn3 AttrMap
_lhsIforcedIrrefutables String
_lhsImainName Options
_lhsIoptions) -> (
         let !_nontsX16 :: T_Nonterminals_s16
_nontsX16 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s16
attach_T_Nonterminals (T_Nonterminals
arg_nonts_)) in
         let !_nontsOaugmentsIn :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_nontsOaugmentsIn = forall a. a -> a
rule28 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_augmentsMap_ in
         let !_nontsOoptions :: Options
_nontsOoptions = Options -> Options
rule35 Options
_lhsIoptions in
         let !_nontsOforcedIrrefutables :: AttrMap
_nontsOforcedIrrefutables = AttrMap -> AttrMap
rule33 AttrMap
_lhsIforcedIrrefutables in
         let !_nontsOmainName :: String
_nontsOmainName = String -> String
rule34 String
_lhsImainName in
         let !(T_Nonterminals_vOut19 AttrMap
_nontsIallAttributes Map NontermIdent Attributes
_nontsIinhMap' Map NontermIdent Attributes
_nontsIsynMap' T_Nonterminals_s36
_nontsX36) = T_Nonterminals_s16 -> forall t. K_Nonterminals_s16 t -> t
inv_Nonterminals_s16 T_Nonterminals_s16
_nontsX16 K_Nonterminals_s16 T_Nonterminals_v19
K_Nonterminals_v19 (T_Nonterminals_vIn19
T_Nonterminals_vIn19 ) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule30 AttrMap
_nontsIallAttributes in
         let !_nontsOinhMap :: Map NontermIdent Attributes
_nontsOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule26 Map NontermIdent Attributes
_nontsIinhMap' in
         let !_nontsOsynMap :: Map NontermIdent Attributes
_nontsOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule27 Map NontermIdent Attributes
_nontsIsynMap' in
         let !(T_Nonterminals_vOut20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_nontsIaugmentsOut Seq Error
_nontsIerrors Nonterminals
_nontsIoutput) = T_Nonterminals_s36 -> T_Nonterminals_v20
inv_Nonterminals_s36 T_Nonterminals_s36
_nontsX36 (Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminals_vIn20
T_Nonterminals_vIn20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_nontsOaugmentsIn AttrMap
_nontsOforcedIrrefutables Map NontermIdent Attributes
_nontsOinhMap String
_nontsOmainName Options
_nontsOoptions Map NontermIdent Attributes
_nontsOsynMap) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule31 Seq Error
_nontsIerrors in
         let _lhsOoutput :: Grammar
             !_lhsOoutput :: Grammar
_lhsOoutput = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Nonterminals
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> ContextMap
-> Derivings
-> AttrOrderMap
-> Map
     NontermIdent
     (Map
        NontermIdent
        (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
-> ParamMap
-> PragmaMap
-> QuantMap
-> TypeSyns
-> UniqueMap
-> UseMap
-> Set NontermIdent
-> Grammar
rule29 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_nontsIaugmentsOut Nonterminals
_nontsIoutput Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
arg_aroundsMap_ ContextMap
arg_contextMap_ Derivings
arg_derivings_ AttrOrderMap
arg_manualAttrOrderMap_ Map
  NontermIdent
  (Map
     NontermIdent
     (Map NontermIdent (NontermIdent, [NontermIdent], Expression)))
arg_mergeMap_ ParamMap
arg_paramMap_ PragmaMap
arg_pragmas_ QuantMap
arg_quantMap_ TypeSyns
arg_typeSyns_ UniqueMap
arg_uniqueMap_ UseMap
arg_useMap_ Set NontermIdent
arg_wrappers_ in
         let !__result_ :: T_Grammar_vOut3
__result_ = AttrMap -> Seq Error -> Grammar -> T_Grammar_vOut3
T_Grammar_vOut3 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Grammar
_lhsOoutput
          in T_Grammar_vOut3
__result_ )
     in T_Grammar_v3 -> T_Grammar_s6
C_Grammar_s6 T_Grammar_v3
v3
   {-# INLINE rule26 #-}
   {-# LINE 15 "src-ag/DistChildAttr.ag" #-}
   rule26 = \ ((!_nontsIinhMap') :: Map Identifier Attributes) ->
                             {-# LINE 15 "src-ag/DistChildAttr.ag" #-}
                             _nontsIinhMap'
                             {-# LINE 511 "src-generated/Desugar.hs" #-}
   {-# INLINE rule27 #-}
   {-# LINE 16 "src-ag/DistChildAttr.ag" #-}
   rule27 = \ ((!_nontsIsynMap') :: Map Identifier Attributes) ->
                             {-# LINE 16 "src-ag/DistChildAttr.ag" #-}
                             _nontsIsynMap'
                             {-# LINE 517 "src-generated/Desugar.hs" #-}
   {-# INLINE rule28 #-}
   {-# LINE 235 "src-ag/Desugar.ag" #-}
   rule28 = \ !augmentsMap_ ->
                           {-# LINE 235 "src-ag/Desugar.ag" #-}
                           augmentsMap_
                           {-# LINE 523 "src-generated/Desugar.hs" #-}
   {-# INLINE rule29 #-}
   {-# LINE 319 "src-ag/Desugar.ag" #-}
   rule29 = \ ((!_nontsIaugmentsOut) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ((!_nontsIoutput) :: Nonterminals) !aroundsMap_ !contextMap_ !derivings_ !manualAttrOrderMap_ !mergeMap_ !paramMap_ !pragmas_ !quantMap_ !typeSyns_ !uniqueMap_ !useMap_ !wrappers_ ->
                     {-# LINE 319 "src-ag/Desugar.ag" #-}
                     Grammar typeSyns_
                             useMap_
                             derivings_
                             wrappers_
                             _nontsIoutput
                             pragmas_
                             manualAttrOrderMap_
                             paramMap_
                             contextMap_
                             quantMap_
                             uniqueMap_
                             _nontsIaugmentsOut
                             aroundsMap_
                             mergeMap_
                     {-# LINE 542 "src-generated/Desugar.hs" #-}
   {-# INLINE rule30 #-}
   rule30 = \ ((!_nontsIallAttributes) :: AttrMap) ->
     _nontsIallAttributes
   {-# INLINE rule31 #-}
   rule31 = \ ((!_nontsIerrors) :: Seq Error) ->
     _nontsIerrors
   {-# INLINE rule33 #-}
   rule33 = \ ((!_lhsIforcedIrrefutables) :: AttrMap) ->
     _lhsIforcedIrrefutables
   {-# INLINE rule34 #-}
   rule34 = \ ((!_lhsImainName) :: String) ->
     _lhsImainName
   {-# INLINE rule35 #-}
   rule35 = \ ((!_lhsIoptions) :: Options) ->
     _lhsIoptions

-- HsToken -----------------------------------------------------
-- wrapper
data Inh_HsToken  = Inh_HsToken { Inh_HsToken -> Line
addLines_Inh_HsToken :: !(Int), Inh_HsToken -> [(NontermIdent, NontermIdent)]
childInhs_Inh_HsToken :: !([(Identifier, Identifier)]), Inh_HsToken -> [(NontermIdent, NontermIdent)]
childSyns_Inh_HsToken :: !([(Identifier, Identifier)]), Inh_HsToken -> NontermIdent
con_Inh_HsToken :: !(ConstructorIdent), Inh_HsToken -> NontermIdent
nt_Inh_HsToken :: !(NontermIdent), Inh_HsToken -> String
ruleDescr_Inh_HsToken :: !(String), Inh_HsToken -> Bool
useFieldIdent_Inh_HsToken :: !(Bool) }
data Syn_HsToken  = Syn_HsToken { Syn_HsToken -> Line
addLines_Syn_HsToken :: !(Int), Syn_HsToken -> Seq Error
errors_Syn_HsToken :: !(Seq Error), Syn_HsToken -> HsToken
tks_Syn_HsToken :: !(HsToken) }
{-# INLINABLE wrap_HsToken #-}
wrap_HsToken :: T_HsToken  -> Inh_HsToken  -> (Syn_HsToken )
wrap_HsToken :: T_HsToken -> Inh_HsToken -> Syn_HsToken
wrap_HsToken !(T_HsToken Identity T_HsToken_s8
act) !(Inh_HsToken Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_HsToken_s8
sem <- Identity T_HsToken_s8
act
        let arg4 :: T_HsToken_vIn4
arg4 = Line
-> [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> String
-> Bool
-> T_HsToken_vIn4
T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent
        !(T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsToken_s8 -> forall t. K_HsToken_s8 t -> t
inv_HsToken_s8 T_HsToken_s8
sem K_HsToken_s8 T_HsToken_v4
K_HsToken_v4 T_HsToken_vIn4
arg4)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Line -> Seq Error -> HsToken -> Syn_HsToken
Syn_HsToken Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks)
   )

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

-- semantic domain
newtype T_HsToken  = T_HsToken {
                               T_HsToken -> Identity T_HsToken_s8
attach_T_HsToken :: Identity (T_HsToken_s8 )
                               }
data T_HsToken_s8  where C_HsToken_s8 :: {
                                         T_HsToken_s8 -> forall t. K_HsToken_s8 t -> t
inv_HsToken_s8 :: !(forall t. K_HsToken_s8  t -> t)
                                         } -> T_HsToken_s8 
data T_HsToken_s9  = C_HsToken_s9
data T_HsToken_s37  = C_HsToken_s37
newtype T_HsToken_s47  = C_HsToken_s47 {
                                       T_HsToken_s47 -> T_HsToken_v35
inv_HsToken_s47 :: (T_HsToken_v35 )
                                       }
data K_HsToken_s8 k  where
   K_HsToken_v4 :: K_HsToken_s8  (T_HsToken_v4 )
   K_HsToken_v21 :: K_HsToken_s8  (T_HsToken_v21 )
   K_HsToken_v34 :: K_HsToken_s8  (T_HsToken_v34 )
type T_HsToken_v4  = (T_HsToken_vIn4 ) -> (T_HsToken_vOut4 )
data T_HsToken_vIn4  = T_HsToken_vIn4 !(Int) !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent) !(String) !(Bool)
data T_HsToken_vOut4  = T_HsToken_vOut4 !(Int) !(Seq Error) !(HsToken)
type T_HsToken_v21  = (T_HsToken_vIn21 ) -> (T_HsToken_vOut21 )
data T_HsToken_vIn21  = T_HsToken_vIn21 !(Int) !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent) !(String) !(Bool)
data T_HsToken_vOut21  = T_HsToken_vOut21 !(Int) !(Seq Error) !(HsToken)
type T_HsToken_v34  = (T_HsToken_vIn34 ) -> (T_HsToken_vOut34 )
data T_HsToken_vIn34  = T_HsToken_vIn34 !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent)
data T_HsToken_vOut34  = T_HsToken_vOut34 !(Seq Error) !(T_HsToken_s47 )
type T_HsToken_v35  = (T_HsToken_vIn35 ) -> (T_HsToken_vOut35 )
data T_HsToken_vIn35  = T_HsToken_vIn35 !(Int) !(String) !(Bool)
data T_HsToken_vOut35  = T_HsToken_vOut35 !(Int) !(HsToken)
{-# NOINLINE sem_HsToken_AGLocal #-}
sem_HsToken_AGLocal :: (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGLocal :: NontermIdent -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGLocal !NontermIdent
arg_var_ !Pos
arg_pos_ Maybe String
_ = Identity T_HsToken_s8 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s8
st8) where
   {-# NOINLINE st8 #-}
   !st8 :: T_HsToken_s8
st8 = let
      k8 :: K_HsToken_s8  t -> t
      k8 :: forall t. K_HsToken_s8 t -> t
k8 K_HsToken_s8 t
K_HsToken_v4 = T_HsToken_v4
v4
      k8 K_HsToken_s8 t
K_HsToken_v21 = T_HsToken_vIn21 -> T_HsToken_vOut21
v21
      k8 K_HsToken_s8 t
K_HsToken_v34 = T_HsToken_vIn34 -> T_HsToken_vOut34
v34
      v4 :: T_HsToken_v4 
      v4 :: T_HsToken_v4
v4 = \ !(T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule38  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Bool -> Line
rule36 Line
_lhsIaddLines Bool
_lhsIuseFieldIdent in
         let !_tks :: HsToken
_tks = Line -> String -> Bool -> Pos -> NontermIdent -> HsToken
rule37 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent Pos
arg_pos_ NontermIdent
arg_var_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule39 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut4
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut4
T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut4
__result_ )
      v21 :: T_HsToken_v21 
      v21 :: T_HsToken_vIn21 -> T_HsToken_vOut21
v21 = \ !(T_HsToken_vIn21 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule38  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Bool -> Line
rule36 Line
_lhsIaddLines Bool
_lhsIuseFieldIdent in
         let !_tks :: HsToken
_tks = Line -> String -> Bool -> Pos -> NontermIdent -> HsToken
rule37 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent Pos
arg_pos_ NontermIdent
arg_var_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule39 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut21
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut21
T_HsToken_vOut21 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut21
__result_ )
      v34 :: T_HsToken_v34 
      v34 :: T_HsToken_vIn34 -> T_HsToken_vOut34
v34 = \ !(T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule38  () in
         let !__st_ :: T_HsToken_s47
__st_ = () -> T_HsToken_s47
st47  ()
             !__result_ :: T_HsToken_vOut34
__result_ = Seq Error -> T_HsToken_s47 -> T_HsToken_vOut34
T_HsToken_vOut34 Seq Error
_lhsOerrors T_HsToken_s47
__st_
          in T_HsToken_vOut34
__result_ )
     in (forall t. K_HsToken_s8 t -> t) -> T_HsToken_s8
C_HsToken_s8 forall t. K_HsToken_s8 t -> t
k8
   {-# NOINLINE st47 #-}
   st47 :: () -> T_HsToken_s47
st47 = \  (()
_ :: ()) -> let
      v35 :: T_HsToken_v35 
      v35 :: T_HsToken_v35
v35 = \ !(T_HsToken_vIn35 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Bool -> Line
rule36 Line
_lhsIaddLines Bool
_lhsIuseFieldIdent in
         let !_tks :: HsToken
_tks = Line -> String -> Bool -> Pos -> NontermIdent -> HsToken
rule37 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent Pos
arg_pos_ NontermIdent
arg_var_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule39 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut35
__result_ = Line -> HsToken -> T_HsToken_vOut35
T_HsToken_vOut35 Line
_lhsOaddLines HsToken
_lhsOtks
          in T_HsToken_vOut35
__result_ )
     in T_HsToken_v35 -> T_HsToken_s47
C_HsToken_s47 T_HsToken_v35
v35
   {-# NOINLINE[1] rule36 #-}
   {-# LINE 74 "src-ag/Desugar.ag" #-}
   rule36 = \ ((!_lhsIaddLines) :: Int) ((!_lhsIuseFieldIdent) :: Bool) ->
                       {-# LINE 74 "src-ag/Desugar.ag" #-}
                       if _lhsIuseFieldIdent
                       then _lhsIaddLines + 1
                       else _lhsIaddLines
                       {-# LINE 669 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule37 #-}
   {-# LINE 77 "src-ag/Desugar.ag" #-}
   rule37 = \ ((!_lhsIaddLines) :: Int) ((!_lhsIruleDescr) :: String) ((!_lhsIuseFieldIdent) :: Bool) !pos_ !var_ ->
                  {-# LINE 77 "src-ag/Desugar.ag" #-}
                  AGLocal var_ (addl _lhsIaddLines pos_) (if _lhsIuseFieldIdent then Just _lhsIruleDescr else Nothing)
                  {-# LINE 675 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule38 #-}
   rule38 = \  (_ :: ()) ->
     Seq.empty
   {-# NOINLINE[1] rule39 #-}
   rule39 = \ !_tks ->
     _tks
{-# NOINLINE sem_HsToken_AGField #-}
sem_HsToken_AGField :: (Identifier) -> (Identifier) -> (Pos) -> (Maybe String) -> T_HsToken 
sem_HsToken_AGField :: NontermIdent -> NontermIdent -> Pos -> Maybe String -> T_HsToken
sem_HsToken_AGField !NontermIdent
arg_field_ !NontermIdent
arg_attr_ !Pos
arg_pos_ Maybe String
_ = Identity T_HsToken_s8 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s8
st8) where
   {-# NOINLINE st8 #-}
   !st8 :: T_HsToken_s8
st8 = let
      k8 :: K_HsToken_s8  t -> t
      k8 :: forall t. K_HsToken_s8 t -> t
k8 K_HsToken_s8 t
K_HsToken_v4 = T_HsToken_v4
v4
      k8 K_HsToken_s8 t
K_HsToken_v21 = T_HsToken_vIn21 -> T_HsToken_vOut21
v21
      k8 K_HsToken_s8 t
K_HsToken_v34 = T_HsToken_vIn34 -> T_HsToken_vOut34
v34
      v4 :: T_HsToken_v4 
      v4 :: T_HsToken_v4
v4 = \ !(T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_mField :: Maybe NontermIdent
_mField = [(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> Maybe NontermIdent
rule40 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_field' :: NontermIdent
_field' = forall {b}. Maybe b -> b -> b
rule41 Maybe NontermIdent
_mField NontermIdent
arg_field_ in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = NontermIdent -> Line -> Bool -> NontermIdent -> Line
rule43 NontermIdent
_field' Line
_lhsIaddLines Bool
_lhsIuseFieldIdent NontermIdent
arg_field_ in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}.
NontermIdent
-> NontermIdent -> Maybe a -> NontermIdent -> Seq Error
rule42 NontermIdent
_lhsIcon NontermIdent
_lhsInt Maybe NontermIdent
_mField NontermIdent
arg_field_ in
         let !_tks :: HsToken
_tks = NontermIdent
-> Line -> String -> Bool -> NontermIdent -> Pos -> HsToken
rule44 NontermIdent
_field' Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent NontermIdent
arg_attr_ Pos
arg_pos_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule45 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut4
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut4
T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut4
__result_ )
      v21 :: T_HsToken_v21 
      v21 :: T_HsToken_vIn21 -> T_HsToken_vOut21
v21 = \ !(T_HsToken_vIn21 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_mField :: Maybe NontermIdent
_mField = [(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> Maybe NontermIdent
rule40 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_field' :: NontermIdent
_field' = forall {b}. Maybe b -> b -> b
rule41 Maybe NontermIdent
_mField NontermIdent
arg_field_ in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = NontermIdent -> Line -> Bool -> NontermIdent -> Line
rule43 NontermIdent
_field' Line
_lhsIaddLines Bool
_lhsIuseFieldIdent NontermIdent
arg_field_ in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}.
NontermIdent
-> NontermIdent -> Maybe a -> NontermIdent -> Seq Error
rule42 NontermIdent
_lhsIcon NontermIdent
_lhsInt Maybe NontermIdent
_mField NontermIdent
arg_field_ in
         let !_tks :: HsToken
_tks = NontermIdent
-> Line -> String -> Bool -> NontermIdent -> Pos -> HsToken
rule44 NontermIdent
_field' Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent NontermIdent
arg_attr_ Pos
arg_pos_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule45 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut21
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut21
T_HsToken_vOut21 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut21
__result_ )
      v34 :: T_HsToken_v34 
      v34 :: T_HsToken_vIn34 -> T_HsToken_vOut34
v34 = \ !(T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_mField :: Maybe NontermIdent
_mField = [(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> Maybe NontermIdent
rule40 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}.
NontermIdent
-> NontermIdent -> Maybe a -> NontermIdent -> Seq Error
rule42 NontermIdent
_lhsIcon NontermIdent
_lhsInt Maybe NontermIdent
_mField NontermIdent
arg_field_ in
         let !__st_ :: T_HsToken_s47
__st_ = Maybe NontermIdent -> T_HsToken_s47
st47 Maybe NontermIdent
_mField
             !__result_ :: T_HsToken_vOut34
__result_ = Seq Error -> T_HsToken_s47 -> T_HsToken_vOut34
T_HsToken_vOut34 Seq Error
_lhsOerrors T_HsToken_s47
__st_
          in T_HsToken_vOut34
__result_ )
     in (forall t. K_HsToken_s8 t -> t) -> T_HsToken_s8
C_HsToken_s8 forall t. K_HsToken_s8 t -> t
k8
   {-# NOINLINE st47 #-}
   st47 :: Maybe NontermIdent -> T_HsToken_s47
st47 = \ !Maybe NontermIdent
_mField -> let
      v35 :: T_HsToken_v35 
      v35 :: T_HsToken_v35
v35 = \ !(T_HsToken_vIn35 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_field' :: NontermIdent
_field' = forall {b}. Maybe b -> b -> b
rule41 Maybe NontermIdent
_mField NontermIdent
arg_field_ in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = NontermIdent -> Line -> Bool -> NontermIdent -> Line
rule43 NontermIdent
_field' Line
_lhsIaddLines Bool
_lhsIuseFieldIdent NontermIdent
arg_field_ in
         let !_tks :: HsToken
_tks = NontermIdent
-> Line -> String -> Bool -> NontermIdent -> Pos -> HsToken
rule44 NontermIdent
_field' Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent NontermIdent
arg_attr_ Pos
arg_pos_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule45 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut35
__result_ = Line -> HsToken -> T_HsToken_vOut35
T_HsToken_vOut35 Line
_lhsOaddLines HsToken
_lhsOtks
          in T_HsToken_vOut35
__result_ )
     in T_HsToken_v35 -> T_HsToken_s47
C_HsToken_s47 T_HsToken_v35
v35
   {-# NOINLINE[1] rule40 #-}
   {-# LINE 79 "src-ag/Desugar.ag" #-}
   rule40 = \ ((!_lhsIchildSyns) :: [(Identifier, Identifier)]) !attr_ !field_ ->
                     {-# LINE 79 "src-ag/Desugar.ag" #-}
                     findField field_ attr_ _lhsIchildSyns
                     {-# LINE 744 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule41 #-}
   {-# LINE 81 "src-ag/Desugar.ag" #-}
   rule41 = \ !_mField !field_ ->
                     {-# LINE 81 "src-ag/Desugar.ag" #-}
                     maybe field_ id _mField
                     {-# LINE 750 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule42 #-}
   {-# LINE 82 "src-ag/Desugar.ag" #-}
   rule42 = \ ((!_lhsIcon) :: ConstructorIdent) ((!_lhsInt) :: NontermIdent) !_mField !field_ ->
                     {-# LINE 82 "src-ag/Desugar.ag" #-}
                     maybe (Seq.singleton (UndefAttr _lhsInt _lhsIcon field_ (Ident "<ANY>" (getPos field_)) False)) (const Seq.empty) _mField
                     {-# LINE 756 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule43 #-}
   {-# LINE 84 "src-ag/Desugar.ag" #-}
   rule43 = \ !_field' ((!_lhsIaddLines) :: Int) ((!_lhsIuseFieldIdent) :: Bool) !field_ ->
                       {-# LINE 84 "src-ag/Desugar.ag" #-}
                       if _lhsIuseFieldIdent || length (getName field_) < length (getName _field'    )
                       then _lhsIaddLines + 1
                       else _lhsIaddLines
                       {-# LINE 764 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule44 #-}
   {-# LINE 88 "src-ag/Desugar.ag" #-}
   rule44 = \ !_field' ((!_lhsIaddLines) :: Int) ((!_lhsIruleDescr) :: String) ((!_lhsIuseFieldIdent) :: Bool) !attr_ !pos_ ->
                  {-# LINE 88 "src-ag/Desugar.ag" #-}
                  AGField _field'     attr_ (addl _lhsIaddLines pos_) (if _lhsIuseFieldIdent then Just _lhsIruleDescr else Nothing)
                  {-# LINE 770 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule45 #-}
   rule45 = \ !_tks ->
     _tks
{-# NOINLINE sem_HsToken_HsToken #-}
sem_HsToken_HsToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_HsToken :: String -> Pos -> T_HsToken
sem_HsToken_HsToken !String
arg_value_ !Pos
arg_pos_ = Identity T_HsToken_s8 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s8
st8) where
   {-# NOINLINE st8 #-}
   !st8 :: T_HsToken_s8
st8 = let
      k8 :: K_HsToken_s8  t -> t
      k8 :: forall t. K_HsToken_s8 t -> t
k8 K_HsToken_s8 t
K_HsToken_v4 = T_HsToken_v4
v4
      k8 K_HsToken_s8 t
K_HsToken_v21 = T_HsToken_vIn21 -> T_HsToken_vOut21
v21
      k8 K_HsToken_s8 t
K_HsToken_v34 = T_HsToken_vIn34 -> T_HsToken_vOut34
v34
      v4 :: T_HsToken_v4 
      v4 :: T_HsToken_v4
v4 = \ !(T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule47  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule49 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule46 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule48 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut4
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut4
T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut4
__result_ )
      v21 :: T_HsToken_v21 
      v21 :: T_HsToken_vIn21 -> T_HsToken_vOut21
v21 = \ !(T_HsToken_vIn21 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule47  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule49 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule46 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule48 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut21
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut21
T_HsToken_vOut21 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut21
__result_ )
      v34 :: T_HsToken_v34 
      v34 :: T_HsToken_vIn34 -> T_HsToken_vOut34
v34 = \ !(T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule47  () in
         let !__st_ :: T_HsToken_s47
__st_ = () -> T_HsToken_s47
st47  ()
             !__result_ :: T_HsToken_vOut34
__result_ = Seq Error -> T_HsToken_s47 -> T_HsToken_vOut34
T_HsToken_vOut34 Seq Error
_lhsOerrors T_HsToken_s47
__st_
          in T_HsToken_vOut34
__result_ )
     in (forall t. K_HsToken_s8 t -> t) -> T_HsToken_s8
C_HsToken_s8 forall t. K_HsToken_s8 t -> t
k8
   {-# NOINLINE st47 #-}
   st47 :: () -> T_HsToken_s47
st47 = \  (()
_ :: ()) -> let
      v35 :: T_HsToken_v35 
      v35 :: T_HsToken_v35
v35 = \ !(T_HsToken_vIn35 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule49 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule46 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule48 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut35
__result_ = Line -> HsToken -> T_HsToken_vOut35
T_HsToken_vOut35 Line
_lhsOaddLines HsToken
_lhsOtks
          in T_HsToken_vOut35
__result_ )
     in T_HsToken_v35 -> T_HsToken_s47
C_HsToken_s47 T_HsToken_v35
v35
   {-# NOINLINE[1] rule46 #-}
   {-# LINE 90 "src-ag/Desugar.ag" #-}
   rule46 = \ ((!_lhsIaddLines) :: Int) !pos_ !value_ ->
                  {-# LINE 90 "src-ag/Desugar.ag" #-}
                  HsToken value_ (addl _lhsIaddLines pos_)
                  {-# LINE 830 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule47 #-}
   rule47 = \  (_ :: ()) ->
     Seq.empty
   {-# NOINLINE[1] rule48 #-}
   rule48 = \ !_tks ->
     _tks
   {-# NOINLINE[1] rule49 #-}
   rule49 = \ ((!_lhsIaddLines) :: Int) ->
     _lhsIaddLines
{-# NOINLINE sem_HsToken_CharToken #-}
sem_HsToken_CharToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_CharToken :: String -> Pos -> T_HsToken
sem_HsToken_CharToken !String
arg_value_ !Pos
arg_pos_ = Identity T_HsToken_s8 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s8
st8) where
   {-# NOINLINE st8 #-}
   !st8 :: T_HsToken_s8
st8 = let
      k8 :: K_HsToken_s8  t -> t
      k8 :: forall t. K_HsToken_s8 t -> t
k8 K_HsToken_s8 t
K_HsToken_v4 = T_HsToken_v4
v4
      k8 K_HsToken_s8 t
K_HsToken_v21 = T_HsToken_vIn21 -> T_HsToken_vOut21
v21
      k8 K_HsToken_s8 t
K_HsToken_v34 = T_HsToken_vIn34 -> T_HsToken_vOut34
v34
      v4 :: T_HsToken_v4 
      v4 :: T_HsToken_v4
v4 = \ !(T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule51  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule53 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule50 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule52 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut4
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut4
T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut4
__result_ )
      v21 :: T_HsToken_v21 
      v21 :: T_HsToken_vIn21 -> T_HsToken_vOut21
v21 = \ !(T_HsToken_vIn21 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule51  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule53 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule50 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule52 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut21
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut21
T_HsToken_vOut21 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut21
__result_ )
      v34 :: T_HsToken_v34 
      v34 :: T_HsToken_vIn34 -> T_HsToken_vOut34
v34 = \ !(T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule51  () in
         let !__st_ :: T_HsToken_s47
__st_ = () -> T_HsToken_s47
st47  ()
             !__result_ :: T_HsToken_vOut34
__result_ = Seq Error -> T_HsToken_s47 -> T_HsToken_vOut34
T_HsToken_vOut34 Seq Error
_lhsOerrors T_HsToken_s47
__st_
          in T_HsToken_vOut34
__result_ )
     in (forall t. K_HsToken_s8 t -> t) -> T_HsToken_s8
C_HsToken_s8 forall t. K_HsToken_s8 t -> t
k8
   {-# NOINLINE st47 #-}
   st47 :: () -> T_HsToken_s47
st47 = \  (()
_ :: ()) -> let
      v35 :: T_HsToken_v35 
      v35 :: T_HsToken_v35
v35 = \ !(T_HsToken_vIn35 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule53 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule50 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule52 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut35
__result_ = Line -> HsToken -> T_HsToken_vOut35
T_HsToken_vOut35 Line
_lhsOaddLines HsToken
_lhsOtks
          in T_HsToken_vOut35
__result_ )
     in T_HsToken_v35 -> T_HsToken_s47
C_HsToken_s47 T_HsToken_v35
v35
   {-# NOINLINE[1] rule50 #-}
   {-# LINE 92 "src-ag/Desugar.ag" #-}
   rule50 = \ ((!_lhsIaddLines) :: Int) !pos_ !value_ ->
                  {-# LINE 92 "src-ag/Desugar.ag" #-}
                  CharToken value_ (addl _lhsIaddLines pos_)
                  {-# LINE 896 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule51 #-}
   rule51 = \  (_ :: ()) ->
     Seq.empty
   {-# NOINLINE[1] rule52 #-}
   rule52 = \ !_tks ->
     _tks
   {-# NOINLINE[1] rule53 #-}
   rule53 = \ ((!_lhsIaddLines) :: Int) ->
     _lhsIaddLines
{-# NOINLINE sem_HsToken_StrToken #-}
sem_HsToken_StrToken :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_StrToken :: String -> Pos -> T_HsToken
sem_HsToken_StrToken !String
arg_value_ !Pos
arg_pos_ = Identity T_HsToken_s8 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s8
st8) where
   {-# NOINLINE st8 #-}
   !st8 :: T_HsToken_s8
st8 = let
      k8 :: K_HsToken_s8  t -> t
      k8 :: forall t. K_HsToken_s8 t -> t
k8 K_HsToken_s8 t
K_HsToken_v4 = T_HsToken_v4
v4
      k8 K_HsToken_s8 t
K_HsToken_v21 = T_HsToken_vIn21 -> T_HsToken_vOut21
v21
      k8 K_HsToken_s8 t
K_HsToken_v34 = T_HsToken_vIn34 -> T_HsToken_vOut34
v34
      v4 :: T_HsToken_v4 
      v4 :: T_HsToken_v4
v4 = \ !(T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule55  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule57 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule54 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule56 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut4
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut4
T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut4
__result_ )
      v21 :: T_HsToken_v21 
      v21 :: T_HsToken_vIn21 -> T_HsToken_vOut21
v21 = \ !(T_HsToken_vIn21 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule55  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule57 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule54 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule56 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut21
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut21
T_HsToken_vOut21 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut21
__result_ )
      v34 :: T_HsToken_v34 
      v34 :: T_HsToken_vIn34 -> T_HsToken_vOut34
v34 = \ !(T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule55  () in
         let !__st_ :: T_HsToken_s47
__st_ = () -> T_HsToken_s47
st47  ()
             !__result_ :: T_HsToken_vOut34
__result_ = Seq Error -> T_HsToken_s47 -> T_HsToken_vOut34
T_HsToken_vOut34 Seq Error
_lhsOerrors T_HsToken_s47
__st_
          in T_HsToken_vOut34
__result_ )
     in (forall t. K_HsToken_s8 t -> t) -> T_HsToken_s8
C_HsToken_s8 forall t. K_HsToken_s8 t -> t
k8
   {-# NOINLINE st47 #-}
   st47 :: () -> T_HsToken_s47
st47 = \  (()
_ :: ()) -> let
      v35 :: T_HsToken_v35 
      v35 :: T_HsToken_v35
v35 = \ !(T_HsToken_vIn35 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule57 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> Pos -> String -> HsToken
rule54 Line
_lhsIaddLines Pos
arg_pos_ String
arg_value_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule56 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut35
__result_ = Line -> HsToken -> T_HsToken_vOut35
T_HsToken_vOut35 Line
_lhsOaddLines HsToken
_lhsOtks
          in T_HsToken_vOut35
__result_ )
     in T_HsToken_v35 -> T_HsToken_s47
C_HsToken_s47 T_HsToken_v35
v35
   {-# NOINLINE[1] rule54 #-}
   {-# LINE 94 "src-ag/Desugar.ag" #-}
   rule54 = \ ((!_lhsIaddLines) :: Int) !pos_ !value_ ->
                  {-# LINE 94 "src-ag/Desugar.ag" #-}
                  StrToken value_ (addl _lhsIaddLines pos_)
                  {-# LINE 962 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule55 #-}
   rule55 = \  (_ :: ()) ->
     Seq.empty
   {-# NOINLINE[1] rule56 #-}
   rule56 = \ !_tks ->
     _tks
   {-# NOINLINE[1] rule57 #-}
   rule57 = \ ((!_lhsIaddLines) :: Int) ->
     _lhsIaddLines
{-# NOINLINE sem_HsToken_Err #-}
sem_HsToken_Err :: (String) -> (Pos) -> T_HsToken 
sem_HsToken_Err :: String -> Pos -> T_HsToken
sem_HsToken_Err !String
arg_mesg_ !Pos
arg_pos_ = Identity T_HsToken_s8 -> T_HsToken
T_HsToken (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsToken_s8
st8) where
   {-# NOINLINE st8 #-}
   !st8 :: T_HsToken_s8
st8 = let
      k8 :: K_HsToken_s8  t -> t
      k8 :: forall t. K_HsToken_s8 t -> t
k8 K_HsToken_s8 t
K_HsToken_v4 = T_HsToken_v4
v4
      k8 K_HsToken_s8 t
K_HsToken_v21 = T_HsToken_vIn21 -> T_HsToken_vOut21
v21
      k8 K_HsToken_s8 t
K_HsToken_v34 = T_HsToken_vIn34 -> T_HsToken_vOut34
v34
      v4 :: T_HsToken_v4 
      v4 :: T_HsToken_v4
v4 = \ !(T_HsToken_vIn4 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule59  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule61 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> String -> Pos -> HsToken
rule58 Line
_lhsIaddLines String
arg_mesg_ Pos
arg_pos_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule60 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut4
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut4
T_HsToken_vOut4 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut4
__result_ )
      v21 :: T_HsToken_v21 
      v21 :: T_HsToken_vIn21 -> T_HsToken_vOut21
v21 = \ !(T_HsToken_vIn21 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule59  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule61 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> String -> Pos -> HsToken
rule58 Line
_lhsIaddLines String
arg_mesg_ Pos
arg_pos_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule60 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut21
__result_ = Line -> Seq Error -> HsToken -> T_HsToken_vOut21
T_HsToken_vOut21 Line
_lhsOaddLines Seq Error
_lhsOerrors HsToken
_lhsOtks
          in T_HsToken_vOut21
__result_ )
      v34 :: T_HsToken_v34 
      v34 :: T_HsToken_vIn34 -> T_HsToken_vOut34
v34 = \ !(T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule59  () in
         let !__st_ :: T_HsToken_s47
__st_ = () -> T_HsToken_s47
st47  ()
             !__result_ :: T_HsToken_vOut34
__result_ = Seq Error -> T_HsToken_s47 -> T_HsToken_vOut34
T_HsToken_vOut34 Seq Error
_lhsOerrors T_HsToken_s47
__st_
          in T_HsToken_vOut34
__result_ )
     in (forall t. K_HsToken_s8 t -> t) -> T_HsToken_s8
C_HsToken_s8 forall t. K_HsToken_s8 t -> t
k8
   {-# NOINLINE st47 #-}
   st47 :: () -> T_HsToken_s47
st47 = \  (()
_ :: ()) -> let
      v35 :: T_HsToken_v35 
      v35 :: T_HsToken_v35
v35 = \ !(T_HsToken_vIn35 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule61 Line
_lhsIaddLines in
         let !_tks :: HsToken
_tks = Line -> String -> Pos -> HsToken
rule58 Line
_lhsIaddLines String
arg_mesg_ Pos
arg_pos_ in
         let _lhsOtks :: HsToken
             !_lhsOtks :: HsToken
_lhsOtks = forall a. a -> a
rule60 HsToken
_tks in
         let !__result_ :: T_HsToken_vOut35
__result_ = Line -> HsToken -> T_HsToken_vOut35
T_HsToken_vOut35 Line
_lhsOaddLines HsToken
_lhsOtks
          in T_HsToken_vOut35
__result_ )
     in T_HsToken_v35 -> T_HsToken_s47
C_HsToken_s47 T_HsToken_v35
v35
   {-# NOINLINE[1] rule58 #-}
   {-# LINE 96 "src-ag/Desugar.ag" #-}
   rule58 = \ ((!_lhsIaddLines) :: Int) !mesg_ !pos_ ->
                  {-# LINE 96 "src-ag/Desugar.ag" #-}
                  Err mesg_ (addl _lhsIaddLines pos_)
                  {-# LINE 1028 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule59 #-}
   rule59 = \  (_ :: ()) ->
     Seq.empty
   {-# NOINLINE[1] rule60 #-}
   rule60 = \ !_tks ->
     _tks
   {-# NOINLINE[1] rule61 #-}
   rule61 = \ ((!_lhsIaddLines) :: Int) ->
     _lhsIaddLines

-- HsTokens ----------------------------------------------------
-- wrapper
data Inh_HsTokens  = Inh_HsTokens { Inh_HsTokens -> Line
addLines_Inh_HsTokens :: !(Int), Inh_HsTokens -> [(NontermIdent, NontermIdent)]
childInhs_Inh_HsTokens :: !([(Identifier, Identifier)]), Inh_HsTokens -> [(NontermIdent, NontermIdent)]
childSyns_Inh_HsTokens :: !([(Identifier, Identifier)]), Inh_HsTokens -> NontermIdent
con_Inh_HsTokens :: !(ConstructorIdent), Inh_HsTokens -> NontermIdent
nt_Inh_HsTokens :: !(NontermIdent), Inh_HsTokens -> String
ruleDescr_Inh_HsTokens :: !(String), Inh_HsTokens -> Bool
useFieldIdent_Inh_HsTokens :: !(Bool) }
data Syn_HsTokens  = Syn_HsTokens { Syn_HsTokens -> Line
addLines_Syn_HsTokens :: !(Int), Syn_HsTokens -> Seq Error
errors_Syn_HsTokens :: !(Seq Error), Syn_HsTokens -> HsTokens
tks_Syn_HsTokens :: !(HsTokens) }
{-# INLINABLE wrap_HsTokens #-}
wrap_HsTokens :: T_HsTokens  -> Inh_HsTokens  -> (Syn_HsTokens )
wrap_HsTokens :: T_HsTokens -> Inh_HsTokens -> Syn_HsTokens
wrap_HsTokens !(T_HsTokens Identity T_HsTokens_s10
act) !(Inh_HsTokens Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_HsTokens_s10
sem <- Identity T_HsTokens_s10
act
        let arg5 :: T_HsTokens_vIn5
arg5 = Line
-> [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> String
-> Bool
-> T_HsTokens_vIn5
T_HsTokens_vIn5 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent
        !(T_HsTokens_vOut5 Line
_lhsOaddLines Seq Error
_lhsOerrors HsTokens
_lhsOtks) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokens_s10 -> forall t. K_HsTokens_s10 t -> t
inv_HsTokens_s10 T_HsTokens_s10
sem K_HsTokens_s10 T_HsTokens_v5
K_HsTokens_v5 T_HsTokens_vIn5
arg5)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Line -> Seq Error -> HsTokens -> Syn_HsTokens
Syn_HsTokens Line
_lhsOaddLines Seq Error
_lhsOerrors HsTokens
_lhsOtks)
   )

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

-- semantic domain
newtype T_HsTokens  = T_HsTokens {
                                 T_HsTokens -> Identity T_HsTokens_s10
attach_T_HsTokens :: Identity (T_HsTokens_s10 )
                                 }
data T_HsTokens_s10  where C_HsTokens_s10 :: {
                                             T_HsTokens_s10 -> forall t. K_HsTokens_s10 t -> t
inv_HsTokens_s10 :: !(forall t. K_HsTokens_s10  t -> t)
                                             } -> T_HsTokens_s10 
data T_HsTokens_s11  = C_HsTokens_s11
newtype T_HsTokens_s38  = C_HsTokens_s38 {
                                         T_HsTokens_s38 -> T_HsTokens_v23
inv_HsTokens_s38 :: (T_HsTokens_v23 )
                                         }
data T_HsTokens_s39  = C_HsTokens_s39
data K_HsTokens_s10 k  where
   K_HsTokens_v5 :: K_HsTokens_s10  (T_HsTokens_v5 )
   K_HsTokens_v22 :: K_HsTokens_s10  (T_HsTokens_v22 )
   K_HsTokens_v24 :: K_HsTokens_s10  (T_HsTokens_v24 )
type T_HsTokens_v5  = (T_HsTokens_vIn5 ) -> (T_HsTokens_vOut5 )
data T_HsTokens_vIn5  = T_HsTokens_vIn5 !(Int) !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent) !(String) !(Bool)
data T_HsTokens_vOut5  = T_HsTokens_vOut5 !(Int) !(Seq Error) !(HsTokens)
type T_HsTokens_v22  = (T_HsTokens_vIn22 ) -> (T_HsTokens_vOut22 )
data T_HsTokens_vIn22  = T_HsTokens_vIn22 !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent)
data T_HsTokens_vOut22  = T_HsTokens_vOut22 !(Seq Error) !(T_HsTokens_s38 )
type T_HsTokens_v23  = (T_HsTokens_vIn23 ) -> (T_HsTokens_vOut23 )
data T_HsTokens_vIn23  = T_HsTokens_vIn23 !(Int) !(String) !(Bool)
data T_HsTokens_vOut23  = T_HsTokens_vOut23 !(Int) !(HsTokens)
type T_HsTokens_v24  = (T_HsTokens_vIn24 ) -> (T_HsTokens_vOut24 )
data T_HsTokens_vIn24  = T_HsTokens_vIn24 !(Int) !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent) !(String) !(Bool)
data T_HsTokens_vOut24  = T_HsTokens_vOut24 !(Int) !(Seq Error) !(HsTokens)
{-# NOINLINE sem_HsTokens_Cons #-}
sem_HsTokens_Cons :: T_HsToken  -> T_HsTokens  -> T_HsTokens 
sem_HsTokens_Cons :: T_HsToken -> T_HsTokens -> T_HsTokens
sem_HsTokens_Cons T_HsToken
arg_hd_ T_HsTokens
arg_tl_ = Identity T_HsTokens_s10 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s10
st10) where
   {-# NOINLINE st10 #-}
   !st10 :: T_HsTokens_s10
st10 = let
      k10 :: K_HsTokens_s10  t -> t
      k10 :: forall t. K_HsTokens_s10 t -> t
k10 K_HsTokens_s10 t
K_HsTokens_v5 = T_HsTokens_v5
v5
      k10 K_HsTokens_s10 t
K_HsTokens_v22 = T_HsTokens_vIn22 -> T_HsTokens_vOut22
v22
      k10 K_HsTokens_s10 t
K_HsTokens_v24 = T_HsTokens_vIn24 -> T_HsTokens_vOut24
v24
      v5 :: T_HsTokens_v5 
      v5 :: T_HsTokens_v5
v5 = \ !(T_HsTokens_vIn5 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_hdX8 :: T_HsToken_s8
_hdX8 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsToken -> Identity T_HsToken_s8
attach_T_HsToken (T_HsToken
arg_hd_)) in
         let !_tlX10 :: T_HsTokens_s10
_tlX10 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s10
attach_T_HsTokens (T_HsTokens
arg_tl_)) in
         let !_hdOaddLines :: Line
_hdOaddLines = Line -> Line
rule66 Line
_lhsIaddLines in
         let !_hdOchildSyns :: [(NontermIdent, NontermIdent)]
_hdOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule68 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_hdOuseFieldIdent :: Bool
_hdOuseFieldIdent = Bool -> Bool
rule72 Bool
_lhsIuseFieldIdent in
         let !_tlOchildSyns :: [(NontermIdent, NontermIdent)]
_tlOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule75 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_tlOuseFieldIdent :: Bool
_tlOuseFieldIdent = Bool -> Bool
rule79 Bool
_lhsIuseFieldIdent in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule69 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule70 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule76 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule77 NontermIdent
_lhsInt in
         let !_hdOruleDescr :: String
_hdOruleDescr = String -> String
rule71 String
_lhsIruleDescr in
         let !_tlOruleDescr :: String
_tlOruleDescr = String -> String
rule78 String
_lhsIruleDescr in
         let !(T_HsToken_vOut21 Line
_hdIaddLines Seq Error
_hdIerrors HsToken
_hdItks) = T_HsToken_s8 -> forall t. K_HsToken_s8 t -> t
inv_HsToken_s8 T_HsToken_s8
_hdX8 K_HsToken_s8 (T_HsToken_vIn21 -> T_HsToken_vOut21)
K_HsToken_v21 (Line
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> String
-> Bool
-> T_HsToken_vIn21
T_HsToken_vIn21 Line
_hdOaddLines [(NontermIdent, NontermIdent)]
_hdOchildSyns NontermIdent
_hdOcon NontermIdent
_hdOnt String
_hdOruleDescr Bool
_hdOuseFieldIdent) in
         let !(T_HsTokens_vOut22 Seq Error
_tlIerrors T_HsTokens_s38
_tlX38) = T_HsTokens_s10 -> forall t. K_HsTokens_s10 t -> t
inv_HsTokens_s10 T_HsTokens_s10
_tlX10 K_HsTokens_s10 (T_HsTokens_vIn22 -> T_HsTokens_vOut22)
K_HsTokens_v22 ([(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> T_HsTokens_vIn22
T_HsTokens_vIn22 [(NontermIdent, NontermIdent)]
_tlOchildSyns NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let !_tlOaddLines :: Line
_tlOaddLines = Line -> Line
rule73 Line
_hdIaddLines in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule62 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !(T_HsTokens_vOut23 Line
_tlIaddLines HsTokens
_tlItks) = T_HsTokens_s38 -> T_HsTokens_v23
inv_HsTokens_s38 T_HsTokens_s38
_tlX38 (Line -> String -> Bool -> T_HsTokens_vIn23
T_HsTokens_vIn23 Line
_tlOaddLines String
_tlOruleDescr Bool
_tlOuseFieldIdent) in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule65 Line
_tlIaddLines in
         let !_tks :: HsTokens
_tks = HsToken -> HsTokens -> HsTokens
rule63 HsToken
_hdItks HsTokens
_tlItks in
         let _lhsOtks :: HsTokens
             !_lhsOtks :: HsTokens
_lhsOtks = forall a. a -> a
rule64 HsTokens
_tks in
         let !__result_ :: T_HsTokens_vOut5
__result_ = Line -> Seq Error -> HsTokens -> T_HsTokens_vOut5
T_HsTokens_vOut5 Line
_lhsOaddLines Seq Error
_lhsOerrors HsTokens
_lhsOtks
          in T_HsTokens_vOut5
__result_ )
      v22 :: T_HsTokens_v22 
      v22 :: T_HsTokens_vIn22 -> T_HsTokens_vOut22
v22 = \ !(T_HsTokens_vIn22 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_hdX8 :: T_HsToken_s8
_hdX8 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsToken -> Identity T_HsToken_s8
attach_T_HsToken (T_HsToken
arg_hd_)) in
         let !_tlX10 :: T_HsTokens_s10
_tlX10 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s10
attach_T_HsTokens (T_HsTokens
arg_tl_)) in
         let !_hdOchildSyns :: [(NontermIdent, NontermIdent)]
_hdOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule68 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule69 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule70 NontermIdent
_lhsInt in
         let !_tlOchildSyns :: [(NontermIdent, NontermIdent)]
_tlOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule75 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule76 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule77 NontermIdent
_lhsInt in
         let !(T_HsToken_vOut34 Seq Error
_hdIerrors T_HsToken_s47
_hdX47) = T_HsToken_s8 -> forall t. K_HsToken_s8 t -> t
inv_HsToken_s8 T_HsToken_s8
_hdX8 K_HsToken_s8 (T_HsToken_vIn34 -> T_HsToken_vOut34)
K_HsToken_v34 ([(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> T_HsToken_vIn34
T_HsToken_vIn34 [(NontermIdent, NontermIdent)]
_hdOchildSyns NontermIdent
_hdOcon NontermIdent
_hdOnt) in
         let !(T_HsTokens_vOut22 Seq Error
_tlIerrors T_HsTokens_s38
_tlX38) = T_HsTokens_s10 -> forall t. K_HsTokens_s10 t -> t
inv_HsTokens_s10 T_HsTokens_s10
_tlX10 K_HsTokens_s10 (T_HsTokens_vIn22 -> T_HsTokens_vOut22)
K_HsTokens_v22 ([(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> T_HsTokens_vIn22
T_HsTokens_vIn22 [(NontermIdent, NontermIdent)]
_tlOchildSyns NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule62 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !__st_ :: T_HsTokens_s38
__st_ = T_HsToken_s47 -> T_HsTokens_s38 -> T_HsTokens_s38
st38 T_HsToken_s47
_hdX47 T_HsTokens_s38
_tlX38
             !__result_ :: T_HsTokens_vOut22
__result_ = Seq Error -> T_HsTokens_s38 -> T_HsTokens_vOut22
T_HsTokens_vOut22 Seq Error
_lhsOerrors T_HsTokens_s38
__st_
          in T_HsTokens_vOut22
__result_ )
      v24 :: T_HsTokens_v24 
      v24 :: T_HsTokens_vIn24 -> T_HsTokens_vOut24
v24 = \ !(T_HsTokens_vIn24 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_hdX8 :: T_HsToken_s8
_hdX8 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsToken -> Identity T_HsToken_s8
attach_T_HsToken (T_HsToken
arg_hd_)) in
         let !_tlX10 :: T_HsTokens_s10
_tlX10 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s10
attach_T_HsTokens (T_HsTokens
arg_tl_)) in
         let !_hdOaddLines :: Line
_hdOaddLines = Line -> Line
rule66 Line
_lhsIaddLines in
         let !_hdOchildSyns :: [(NontermIdent, NontermIdent)]
_hdOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule68 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_hdOuseFieldIdent :: Bool
_hdOuseFieldIdent = Bool -> Bool
rule72 Bool
_lhsIuseFieldIdent in
         let !_tlOchildSyns :: [(NontermIdent, NontermIdent)]
_tlOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule75 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_tlOuseFieldIdent :: Bool
_tlOuseFieldIdent = Bool -> Bool
rule79 Bool
_lhsIuseFieldIdent in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule69 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule70 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule76 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule77 NontermIdent
_lhsInt in
         let !_hdOruleDescr :: String
_hdOruleDescr = String -> String
rule71 String
_lhsIruleDescr in
         let !_tlOruleDescr :: String
_tlOruleDescr = String -> String
rule78 String
_lhsIruleDescr in
         let !(T_HsToken_vOut21 Line
_hdIaddLines Seq Error
_hdIerrors HsToken
_hdItks) = T_HsToken_s8 -> forall t. K_HsToken_s8 t -> t
inv_HsToken_s8 T_HsToken_s8
_hdX8 K_HsToken_s8 (T_HsToken_vIn21 -> T_HsToken_vOut21)
K_HsToken_v21 (Line
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> String
-> Bool
-> T_HsToken_vIn21
T_HsToken_vIn21 Line
_hdOaddLines [(NontermIdent, NontermIdent)]
_hdOchildSyns NontermIdent
_hdOcon NontermIdent
_hdOnt String
_hdOruleDescr Bool
_hdOuseFieldIdent) in
         let !(T_HsTokens_vOut22 Seq Error
_tlIerrors T_HsTokens_s38
_tlX38) = T_HsTokens_s10 -> forall t. K_HsTokens_s10 t -> t
inv_HsTokens_s10 T_HsTokens_s10
_tlX10 K_HsTokens_s10 (T_HsTokens_vIn22 -> T_HsTokens_vOut22)
K_HsTokens_v22 ([(NontermIdent, NontermIdent)]
-> NontermIdent -> NontermIdent -> T_HsTokens_vIn22
T_HsTokens_vIn22 [(NontermIdent, NontermIdent)]
_tlOchildSyns NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let !_tlOaddLines :: Line
_tlOaddLines = Line -> Line
rule73 Line
_hdIaddLines in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule62 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !(T_HsTokens_vOut23 Line
_tlIaddLines HsTokens
_tlItks) = T_HsTokens_s38 -> T_HsTokens_v23
inv_HsTokens_s38 T_HsTokens_s38
_tlX38 (Line -> String -> Bool -> T_HsTokens_vIn23
T_HsTokens_vIn23 Line
_tlOaddLines String
_tlOruleDescr Bool
_tlOuseFieldIdent) in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule65 Line
_tlIaddLines in
         let !_tks :: HsTokens
_tks = HsToken -> HsTokens -> HsTokens
rule63 HsToken
_hdItks HsTokens
_tlItks in
         let _lhsOtks :: HsTokens
             !_lhsOtks :: HsTokens
_lhsOtks = forall a. a -> a
rule64 HsTokens
_tks in
         let !__result_ :: T_HsTokens_vOut24
__result_ = Line -> Seq Error -> HsTokens -> T_HsTokens_vOut24
T_HsTokens_vOut24 Line
_lhsOaddLines Seq Error
_lhsOerrors HsTokens
_lhsOtks
          in T_HsTokens_vOut24
__result_ )
     in (forall t. K_HsTokens_s10 t -> t) -> T_HsTokens_s10
C_HsTokens_s10 forall t. K_HsTokens_s10 t -> t
k10
   {-# NOINLINE st38 #-}
   st38 :: T_HsToken_s47 -> T_HsTokens_s38 -> T_HsTokens_s38
st38 = \ !T_HsToken_s47
_hdX47 !T_HsTokens_s38
_tlX38 -> let
      v23 :: T_HsTokens_v23 
      v23 :: T_HsTokens_v23
v23 = \ !(T_HsTokens_vIn23 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_hdOaddLines :: Line
_hdOaddLines = Line -> Line
rule66 Line
_lhsIaddLines in
         let !_hdOuseFieldIdent :: Bool
_hdOuseFieldIdent = Bool -> Bool
rule72 Bool
_lhsIuseFieldIdent in
         let !_tlOuseFieldIdent :: Bool
_tlOuseFieldIdent = Bool -> Bool
rule79 Bool
_lhsIuseFieldIdent in
         let !_hdOruleDescr :: String
_hdOruleDescr = String -> String
rule71 String
_lhsIruleDescr in
         let !_tlOruleDescr :: String
_tlOruleDescr = String -> String
rule78 String
_lhsIruleDescr in
         let !(T_HsToken_vOut35 Line
_hdIaddLines HsToken
_hdItks) = T_HsToken_s47 -> T_HsToken_v35
inv_HsToken_s47 T_HsToken_s47
_hdX47 (Line -> String -> Bool -> T_HsToken_vIn35
T_HsToken_vIn35 Line
_hdOaddLines String
_hdOruleDescr Bool
_hdOuseFieldIdent) in
         let !_tlOaddLines :: Line
_tlOaddLines = Line -> Line
rule73 Line
_hdIaddLines in
         let !(T_HsTokens_vOut23 Line
_tlIaddLines HsTokens
_tlItks) = T_HsTokens_s38 -> T_HsTokens_v23
inv_HsTokens_s38 T_HsTokens_s38
_tlX38 (Line -> String -> Bool -> T_HsTokens_vIn23
T_HsTokens_vIn23 Line
_tlOaddLines String
_tlOruleDescr Bool
_tlOuseFieldIdent) in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule65 Line
_tlIaddLines in
         let !_tks :: HsTokens
_tks = HsToken -> HsTokens -> HsTokens
rule63 HsToken
_hdItks HsTokens
_tlItks in
         let _lhsOtks :: HsTokens
             !_lhsOtks :: HsTokens
_lhsOtks = forall a. a -> a
rule64 HsTokens
_tks in
         let !__result_ :: T_HsTokens_vOut23
__result_ = Line -> HsTokens -> T_HsTokens_vOut23
T_HsTokens_vOut23 Line
_lhsOaddLines HsTokens
_lhsOtks
          in T_HsTokens_vOut23
__result_ )
     in T_HsTokens_v23 -> T_HsTokens_s38
C_HsTokens_s38 T_HsTokens_v23
v23
   {-# NOINLINE[1] rule62 #-}
   rule62 :: Seq Error -> Seq Error -> Seq Error
rule62 = \ ((!Seq Error
_hdIerrors) :: Seq Error) ((!Seq Error
_tlIerrors) :: Seq Error) ->
     Seq Error
_hdIerrors forall a. Seq a -> Seq a -> Seq a
Seq.>< Seq Error
_tlIerrors
   {-# NOINLINE[1] rule63 #-}
   rule63 :: HsToken -> HsTokens -> HsTokens
rule63 = \ ((!HsToken
_hdItks) :: HsToken) ((!HsTokens
_tlItks) :: HsTokens) ->
     (:) HsToken
_hdItks HsTokens
_tlItks
   {-# NOINLINE[1] rule64 #-}
   rule64 :: p -> p
rule64 = \ !p
_tks ->
     p
_tks
   {-# NOINLINE[1] rule65 #-}
   rule65 :: Line -> Line
rule65 = \ ((!Line
_tlIaddLines) :: Int) ->
     Line
_tlIaddLines
   {-# NOINLINE[1] rule66 #-}
   rule66 :: Line -> Line
rule66 = \ ((!Line
_lhsIaddLines) :: Int) ->
     Line
_lhsIaddLines
   {-# NOINLINE[1] rule68 #-}
   rule68 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule68 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildSyns) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildSyns
   {-# NOINLINE[1] rule69 #-}
   rule69 :: NontermIdent -> NontermIdent
rule69 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule70 #-}
   rule70 :: NontermIdent -> NontermIdent
rule70 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule71 #-}
   rule71 :: String -> String
rule71 = \ ((!String
_lhsIruleDescr) :: String) ->
     String
_lhsIruleDescr
   {-# NOINLINE[1] rule72 #-}
   rule72 :: Bool -> Bool
rule72 = \ ((!Bool
_lhsIuseFieldIdent) :: Bool) ->
     Bool
_lhsIuseFieldIdent
   {-# NOINLINE[1] rule73 #-}
   rule73 :: Line -> Line
rule73 = \ ((!Line
_hdIaddLines) :: Int) ->
     Line
_hdIaddLines
   {-# NOINLINE[1] rule75 #-}
   rule75 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule75 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildSyns) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildSyns
   {-# NOINLINE[1] rule76 #-}
   rule76 :: NontermIdent -> NontermIdent
rule76 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule77 #-}
   rule77 :: NontermIdent -> NontermIdent
rule77 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule78 #-}
   rule78 :: String -> String
rule78 = \ ((!String
_lhsIruleDescr) :: String) ->
     String
_lhsIruleDescr
   {-# NOINLINE[1] rule79 #-}
   rule79 :: Bool -> Bool
rule79 = \ ((!Bool
_lhsIuseFieldIdent) :: Bool) ->
     Bool
_lhsIuseFieldIdent
{-# NOINLINE sem_HsTokens_Nil #-}
sem_HsTokens_Nil ::  T_HsTokens 
sem_HsTokens_Nil :: T_HsTokens
sem_HsTokens_Nil  = Identity T_HsTokens_s10 -> T_HsTokens
T_HsTokens (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokens_s10
st10) where
   {-# NOINLINE st10 #-}
   !st10 :: T_HsTokens_s10
st10 = let
      k10 :: K_HsTokens_s10  t -> t
      k10 :: forall t. K_HsTokens_s10 t -> t
k10 K_HsTokens_s10 t
K_HsTokens_v5 = T_HsTokens_v5
v5
      k10 K_HsTokens_s10 t
K_HsTokens_v22 = T_HsTokens_vIn22 -> T_HsTokens_vOut22
v22
      k10 K_HsTokens_s10 t
K_HsTokens_v24 = T_HsTokens_vIn24 -> T_HsTokens_vOut24
v24
      v5 :: T_HsTokens_v5 
      v5 :: T_HsTokens_v5
v5 = \ !(T_HsTokens_vIn5 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule80  () in
         let !_tks :: [a]
_tks = forall {a}. () -> [a]
rule81  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule83 Line
_lhsIaddLines in
         let _lhsOtks :: HsTokens
             !_lhsOtks :: HsTokens
_lhsOtks = forall a. a -> a
rule82 forall a. [a]
_tks in
         let !__result_ :: T_HsTokens_vOut5
__result_ = Line -> Seq Error -> HsTokens -> T_HsTokens_vOut5
T_HsTokens_vOut5 Line
_lhsOaddLines Seq Error
_lhsOerrors HsTokens
_lhsOtks
          in T_HsTokens_vOut5
__result_ )
      v22 :: T_HsTokens_v22 
      v22 :: T_HsTokens_vIn22 -> T_HsTokens_vOut22
v22 = \ !(T_HsTokens_vIn22 [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule80  () in
         let !__st_ :: T_HsTokens_s38
__st_ = () -> T_HsTokens_s38
st38  ()
             !__result_ :: T_HsTokens_vOut22
__result_ = Seq Error -> T_HsTokens_s38 -> T_HsTokens_vOut22
T_HsTokens_vOut22 Seq Error
_lhsOerrors T_HsTokens_s38
__st_
          in T_HsTokens_vOut22
__result_ )
      v24 :: T_HsTokens_v24 
      v24 :: T_HsTokens_vIn24 -> T_HsTokens_vOut24
v24 = \ !(T_HsTokens_vIn24 Line
_lhsIaddLines [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule80  () in
         let !_tks :: [a]
_tks = forall {a}. () -> [a]
rule81  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule83 Line
_lhsIaddLines in
         let _lhsOtks :: HsTokens
             !_lhsOtks :: HsTokens
_lhsOtks = forall a. a -> a
rule82 forall a. [a]
_tks in
         let !__result_ :: T_HsTokens_vOut24
__result_ = Line -> Seq Error -> HsTokens -> T_HsTokens_vOut24
T_HsTokens_vOut24 Line
_lhsOaddLines Seq Error
_lhsOerrors HsTokens
_lhsOtks
          in T_HsTokens_vOut24
__result_ )
     in (forall t. K_HsTokens_s10 t -> t) -> T_HsTokens_s10
C_HsTokens_s10 forall t. K_HsTokens_s10 t -> t
k10
   {-# NOINLINE st38 #-}
   st38 :: () -> T_HsTokens_s38
st38 = \  (()
_ :: ()) -> let
      v23 :: T_HsTokens_v23 
      v23 :: T_HsTokens_v23
v23 = \ !(T_HsTokens_vIn23 Line
_lhsIaddLines String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_tks :: [a]
_tks = forall {a}. () -> [a]
rule81  () in
         let _lhsOaddLines :: Int
             !_lhsOaddLines :: Line
_lhsOaddLines = Line -> Line
rule83 Line
_lhsIaddLines in
         let _lhsOtks :: HsTokens
             !_lhsOtks :: HsTokens
_lhsOtks = forall a. a -> a
rule82 forall a. [a]
_tks in
         let !__result_ :: T_HsTokens_vOut23
__result_ = Line -> HsTokens -> T_HsTokens_vOut23
T_HsTokens_vOut23 Line
_lhsOaddLines HsTokens
_lhsOtks
          in T_HsTokens_vOut23
__result_ )
     in T_HsTokens_v23 -> T_HsTokens_s38
C_HsTokens_s38 T_HsTokens_v23
v23
   {-# NOINLINE[1] rule80 #-}
   rule80 :: () -> Seq a
rule80 = \  (()
_ :: ()) ->
     forall a. Seq a
Seq.empty
   {-# NOINLINE[1] rule81 #-}
   rule81 :: () -> [a]
rule81 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule82 #-}
   rule82 :: p -> p
rule82 = \ !p
_tks ->
     p
_tks
   {-# NOINLINE[1] rule83 #-}
   rule83 :: Line -> Line
rule83 = \ ((!Line
_lhsIaddLines) :: Int) ->
     Line
_lhsIaddLines

-- HsTokensRoot ------------------------------------------------
-- wrapper
data Inh_HsTokensRoot  = Inh_HsTokensRoot { Inh_HsTokensRoot -> [(NontermIdent, NontermIdent)]
childInhs_Inh_HsTokensRoot :: !([(Identifier, Identifier)]), Inh_HsTokensRoot -> [(NontermIdent, NontermIdent)]
childSyns_Inh_HsTokensRoot :: !([(Identifier, Identifier)]), Inh_HsTokensRoot -> NontermIdent
con_Inh_HsTokensRoot :: !(ConstructorIdent), Inh_HsTokensRoot -> NontermIdent
nt_Inh_HsTokensRoot :: !(NontermIdent), Inh_HsTokensRoot -> String
ruleDescr_Inh_HsTokensRoot :: !(String), Inh_HsTokensRoot -> Bool
useFieldIdent_Inh_HsTokensRoot :: !(Bool) }
data Syn_HsTokensRoot  = Syn_HsTokensRoot { Syn_HsTokensRoot -> Seq Error
errors_Syn_HsTokensRoot :: !(Seq Error), Syn_HsTokensRoot -> HsTokens
tks_Syn_HsTokensRoot :: !([HsToken]) }
{-# INLINABLE wrap_HsTokensRoot #-}
wrap_HsTokensRoot :: T_HsTokensRoot  -> Inh_HsTokensRoot  -> (Syn_HsTokensRoot )
wrap_HsTokensRoot :: T_HsTokensRoot -> Inh_HsTokensRoot -> Syn_HsTokensRoot
wrap_HsTokensRoot !(T_HsTokensRoot Identity T_HsTokensRoot_s12
act) !(Inh_HsTokensRoot [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_HsTokensRoot_s12
sem <- Identity T_HsTokensRoot_s12
act
        let arg6 :: T_HsTokensRoot_vIn6
arg6 = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> String
-> Bool
-> T_HsTokensRoot_vIn6
T_HsTokensRoot_vIn6 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent
        !(T_HsTokensRoot_vOut6 Seq Error
_lhsOerrors HsTokens
_lhsOtks) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_HsTokensRoot_s12 -> T_HsTokensRoot_v6
inv_HsTokensRoot_s12 T_HsTokensRoot_s12
sem T_HsTokensRoot_vIn6
arg6)
        forall (m :: * -> *) a. Monad m => a -> m a
return (Seq Error -> HsTokens -> Syn_HsTokensRoot
Syn_HsTokensRoot Seq Error
_lhsOerrors HsTokens
_lhsOtks)
   )

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

-- semantic domain
newtype T_HsTokensRoot  = T_HsTokensRoot {
                                         T_HsTokensRoot -> Identity T_HsTokensRoot_s12
attach_T_HsTokensRoot :: Identity (T_HsTokensRoot_s12 )
                                         }
newtype T_HsTokensRoot_s12  = C_HsTokensRoot_s12 {
                                                 T_HsTokensRoot_s12 -> T_HsTokensRoot_v6
inv_HsTokensRoot_s12 :: (T_HsTokensRoot_v6 )
                                                 }
data T_HsTokensRoot_s13  = C_HsTokensRoot_s13
type T_HsTokensRoot_v6  = (T_HsTokensRoot_vIn6 ) -> (T_HsTokensRoot_vOut6 )
data T_HsTokensRoot_vIn6  = T_HsTokensRoot_vIn6 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(NontermIdent) !(String) !(Bool)
data T_HsTokensRoot_vOut6  = T_HsTokensRoot_vOut6 !(Seq Error) !([HsToken])
{-# NOINLINE sem_HsTokensRoot_HsTokensRoot #-}
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens  -> T_HsTokensRoot 
sem_HsTokensRoot_HsTokensRoot :: T_HsTokens -> T_HsTokensRoot
sem_HsTokensRoot_HsTokensRoot T_HsTokens
arg_tokens_ = Identity T_HsTokensRoot_s12 -> T_HsTokensRoot
T_HsTokensRoot (forall (m :: * -> *) a. Monad m => a -> m a
return T_HsTokensRoot_s12
st12) where
   {-# NOINLINE st12 #-}
   !st12 :: T_HsTokensRoot_s12
st12 = let
      v6 :: T_HsTokensRoot_v6 
      v6 :: T_HsTokensRoot_v6
v6 = \ !(T_HsTokensRoot_vIn6 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon NontermIdent
_lhsInt String
_lhsIruleDescr Bool
_lhsIuseFieldIdent) -> (
         let !_tokensX10 :: T_HsTokens_s10
_tokensX10 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_HsTokens -> Identity T_HsTokens_s10
attach_T_HsTokens (T_HsTokens
arg_tokens_)) in
         let !_tokensOaddLines :: Line
_tokensOaddLines = () -> Line
rule84  () in
         let !_tokensOchildSyns :: [(NontermIdent, NontermIdent)]
_tokensOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule88 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_tokensOcon :: NontermIdent
_tokensOcon = NontermIdent -> NontermIdent
rule89 NontermIdent
_lhsIcon in
         let !_tokensOnt :: NontermIdent
_tokensOnt = NontermIdent -> NontermIdent
rule90 NontermIdent
_lhsInt in
         let !_tokensOruleDescr :: String
_tokensOruleDescr = String -> String
rule91 String
_lhsIruleDescr in
         let !_tokensOuseFieldIdent :: Bool
_tokensOuseFieldIdent = Bool -> Bool
rule92 Bool
_lhsIuseFieldIdent in
         let !(T_HsTokens_vOut24 Line
_tokensIaddLines Seq Error
_tokensIerrors HsTokens
_tokensItks) = T_HsTokens_s10 -> forall t. K_HsTokens_s10 t -> t
inv_HsTokens_s10 T_HsTokens_s10
_tokensX10 K_HsTokens_s10 (T_HsTokens_vIn24 -> T_HsTokens_vOut24)
K_HsTokens_v24 (Line
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> String
-> Bool
-> T_HsTokens_vIn24
T_HsTokens_vIn24 Line
_tokensOaddLines [(NontermIdent, NontermIdent)]
_tokensOchildSyns NontermIdent
_tokensOcon NontermIdent
_tokensOnt String
_tokensOruleDescr Bool
_tokensOuseFieldIdent) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule85 Seq Error
_tokensIerrors in
         let _lhsOtks :: [HsToken]
             !_lhsOtks :: HsTokens
_lhsOtks = HsTokens -> HsTokens
rule86 HsTokens
_tokensItks in
         let !__result_ :: T_HsTokensRoot_vOut6
__result_ = Seq Error -> HsTokens -> T_HsTokensRoot_vOut6
T_HsTokensRoot_vOut6 Seq Error
_lhsOerrors HsTokens
_lhsOtks
          in T_HsTokensRoot_vOut6
__result_ )
     in T_HsTokensRoot_v6 -> T_HsTokensRoot_s12
C_HsTokensRoot_s12 T_HsTokensRoot_v6
v6
   {-# INLINE rule84 #-}
   {-# LINE 67 "src-ag/Desugar.ag" #-}
   rule84 = \  (_ :: ()) ->
                          {-# LINE 67 "src-ag/Desugar.ag" #-}
                          0
                          {-# LINE 1358 "src-generated/Desugar.hs" #-}
   {-# INLINE rule85 #-}
   rule85 = \ ((!_tokensIerrors) :: Seq Error) ->
     _tokensIerrors
   {-# INLINE rule86 #-}
   rule86 = \ ((!_tokensItks) :: HsTokens) ->
     _tokensItks
   {-# INLINE rule88 #-}
   rule88 = \ ((!_lhsIchildSyns) :: [(Identifier, Identifier)]) ->
     _lhsIchildSyns
   {-# INLINE rule89 #-}
   rule89 = \ ((!_lhsIcon) :: ConstructorIdent) ->
     _lhsIcon
   {-# INLINE rule90 #-}
   rule90 = \ ((!_lhsInt) :: NontermIdent) ->
     _lhsInt
   {-# INLINE rule91 #-}
   rule91 = \ ((!_lhsIruleDescr) :: String) ->
     _lhsIruleDescr
   {-# INLINE rule92 #-}
   rule92 = \ ((!_lhsIuseFieldIdent) :: Bool) ->
     _lhsIuseFieldIdent

-- Nonterminal -------------------------------------------------
-- wrapper
data Inh_Nonterminal  = Inh_Nonterminal { Inh_Nonterminal
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
augmentsIn_Inh_Nonterminal :: !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), Inh_Nonterminal -> AttrMap
forcedIrrefutables_Inh_Nonterminal :: !(AttrMap), Inh_Nonterminal -> Map NontermIdent Attributes
inhMap_Inh_Nonterminal :: !(Map Identifier Attributes), Inh_Nonterminal -> String
mainName_Inh_Nonterminal :: !(String), Inh_Nonterminal -> Options
options_Inh_Nonterminal :: !(Options), Inh_Nonterminal -> Map NontermIdent Attributes
synMap_Inh_Nonterminal :: !(Map Identifier Attributes) }
data Syn_Nonterminal  = Syn_Nonterminal { Syn_Nonterminal -> AttrMap
allAttributes_Syn_Nonterminal :: !(AttrMap), Syn_Nonterminal
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
augmentsOut_Syn_Nonterminal :: !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), Syn_Nonterminal -> Seq Error
errors_Syn_Nonterminal :: !(Seq Error), Syn_Nonterminal -> Map NontermIdent Attributes
inhMap'_Syn_Nonterminal :: !(Map Identifier Attributes), Syn_Nonterminal -> Nonterminal
output_Syn_Nonterminal :: !(Nonterminal), Syn_Nonterminal -> Map NontermIdent Attributes
synMap'_Syn_Nonterminal :: !(Map Identifier Attributes) }
{-# INLINABLE wrap_Nonterminal #-}
wrap_Nonterminal :: T_Nonterminal  -> Inh_Nonterminal  -> (Syn_Nonterminal )
wrap_Nonterminal :: T_Nonterminal -> Inh_Nonterminal -> Syn_Nonterminal
wrap_Nonterminal !(T_Nonterminal Identity T_Nonterminal_s14
act) !(Inh_Nonterminal Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Nonterminal_s14
sem <- Identity T_Nonterminal_s14
act
        let arg7 :: T_Nonterminal_vIn7
arg7 = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminal_vIn7
T_Nonterminal_vIn7 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap
        !(T_Nonterminal_vOut7 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminal
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap') <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Nonterminal_s14 -> forall t. K_Nonterminal_s14 t -> t
inv_Nonterminal_s14 T_Nonterminal_s14
sem K_Nonterminal_s14 T_Nonterminal_v7
K_Nonterminal_v7 T_Nonterminal_vIn7
arg7)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error
-> Map NontermIdent Attributes
-> Nonterminal
-> Map NontermIdent Attributes
-> Syn_Nonterminal
Syn_Nonterminal AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminal
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap')
   )

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

-- semantic domain
newtype T_Nonterminal  = T_Nonterminal {
                                       T_Nonterminal -> Identity T_Nonterminal_s14
attach_T_Nonterminal :: Identity (T_Nonterminal_s14 )
                                       }
data T_Nonterminal_s14  where C_Nonterminal_s14 :: {
                                                   T_Nonterminal_s14 -> forall t. K_Nonterminal_s14 t -> t
inv_Nonterminal_s14 :: !(forall t. K_Nonterminal_s14  t -> t)
                                                   } -> T_Nonterminal_s14 
data T_Nonterminal_s15  = C_Nonterminal_s15
newtype T_Nonterminal_s46  = C_Nonterminal_s46 {
                                               T_Nonterminal_s46 -> T_Nonterminal_v33
inv_Nonterminal_s46 :: (T_Nonterminal_v33 )
                                               }
data K_Nonterminal_s14 k  where
   K_Nonterminal_v7 :: K_Nonterminal_s14  (T_Nonterminal_v7 )
   K_Nonterminal_v32 :: K_Nonterminal_s14  (T_Nonterminal_v32 )
type T_Nonterminal_v7  = (T_Nonterminal_vIn7 ) -> (T_Nonterminal_vOut7 )
data T_Nonterminal_vIn7  = T_Nonterminal_vIn7 !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(AttrMap) !(Map Identifier Attributes) !(String) !(Options) !(Map Identifier Attributes)
data T_Nonterminal_vOut7  = T_Nonterminal_vOut7 !(AttrMap) !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(Seq Error) !(Map Identifier Attributes) !(Nonterminal) !(Map Identifier Attributes)
type T_Nonterminal_v32  = (T_Nonterminal_vIn32 ) -> (T_Nonterminal_vOut32 )
data T_Nonterminal_vIn32  = T_Nonterminal_vIn32 
data T_Nonterminal_vOut32  = T_Nonterminal_vOut32 !(AttrMap) !(Map Identifier Attributes) !(Map Identifier Attributes) !(T_Nonterminal_s46 )
type T_Nonterminal_v33  = (T_Nonterminal_vIn33 ) -> (T_Nonterminal_vOut33 )
data T_Nonterminal_vIn33  = T_Nonterminal_vIn33 !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(AttrMap) !(Map Identifier Attributes) !(String) !(Options) !(Map Identifier Attributes)
data T_Nonterminal_vOut33  = T_Nonterminal_vOut33 !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(Seq Error) !(Nonterminal)
{-# NOINLINE sem_Nonterminal_Nonterminal #-}
sem_Nonterminal_Nonterminal :: (NontermIdent) -> ([Identifier]) -> (Attributes) -> (Attributes) -> T_Productions  -> T_Nonterminal 
sem_Nonterminal_Nonterminal :: NontermIdent
-> [NontermIdent]
-> Attributes
-> Attributes
-> T_Productions
-> T_Nonterminal
sem_Nonterminal_Nonterminal !NontermIdent
arg_nt_ ![NontermIdent]
arg_params_ !Attributes
arg_inh_ !Attributes
arg_syn_ T_Productions
arg_prods_ = Identity T_Nonterminal_s14 -> T_Nonterminal
T_Nonterminal (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminal_s14
st14) where
   {-# NOINLINE st14 #-}
   !st14 :: T_Nonterminal_s14
st14 = let
      k14 :: K_Nonterminal_s14  t -> t
      k14 :: forall t. K_Nonterminal_s14 t -> t
k14 K_Nonterminal_s14 t
K_Nonterminal_v7 = T_Nonterminal_v7
v7
      k14 K_Nonterminal_s14 t
K_Nonterminal_v32 = T_Nonterminal_vIn32 -> T_Nonterminal_vOut32
v32
      v7 :: T_Nonterminal_v7 
      v7 :: T_Nonterminal_v7
v7 = \ !(T_Nonterminal_vIn7 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_prodsX24 :: T_Productions_s24
_prodsX24 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s24
attach_T_Productions (T_Productions
arg_prods_)) in
         let !_prodsOnt :: NontermIdent
_prodsOnt = forall a. a -> a
rule95 NontermIdent
arg_nt_ in
         let !_augmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_augmentsIn = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> NontermIdent -> Map NontermIdent (Map NontermIdent [Expression])
rule96 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn NontermIdent
arg_nt_ in
         let !_prodsOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_prodsOaugmentsIn = forall a. a -> a
rule104 Map NontermIdent (Map NontermIdent [Expression])
_augmentsIn in
         let !_prodsOinhMap :: Map NontermIdent Attributes
_prodsOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule106 Map NontermIdent Attributes
_lhsIinhMap in
         let !_prodsOoptions :: Options
_prodsOoptions = Options -> Options
rule108 Options
_lhsIoptions in
         let !_prodsOsynMap :: Map NontermIdent Attributes
_prodsOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule109 Map NontermIdent Attributes
_lhsIsynMap in
         let _lhsOinhMap' :: Map Identifier Attributes
             !_lhsOinhMap' :: Map NontermIdent Attributes
_lhsOinhMap' = forall {a} {k}. a -> k -> Map k a
rule93 Attributes
arg_inh_ NontermIdent
arg_nt_ in
         let !_prodsOforcedIrrefutables :: AttrMap
_prodsOforcedIrrefutables = AttrMap -> AttrMap
rule105 AttrMap
_lhsIforcedIrrefutables in
         let !_extraInh :: Attributes
_extraInh = String -> Options -> Attributes
rule98 String
_lhsImainName Options
_lhsIoptions in
         let _lhsOsynMap' :: Map Identifier Attributes
             !_lhsOsynMap' :: Map NontermIdent Attributes
_lhsOsynMap' = forall k a. k -> a -> Map k a
rule94 NontermIdent
arg_nt_ Attributes
arg_syn_ in
         let !(T_Productions_vOut25 AttrMap
_prodsIallAttributes Map NontermIdent (Map NontermIdent [Expression])
_prodsIaugmentsOut Seq Error
_prodsIerrors Productions
_prodsIoutput) = T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 T_Productions_s24
_prodsX24 K_Productions_s24 T_Productions_v25
K_Productions_v25 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Productions_vIn25
T_Productions_vIn25 Map NontermIdent (Map NontermIdent [Expression])
_prodsOaugmentsIn AttrMap
_prodsOforcedIrrefutables Map NontermIdent Attributes
_prodsOinhMap NontermIdent
_prodsOnt Options
_prodsOoptions Map NontermIdent Attributes
_prodsOsynMap) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule100 AttrMap
_prodsIallAttributes in
         let !_augmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_augmentsOut = forall {k}.
Map NontermIdent (Map NontermIdent [Expression])
-> k -> Map k (Map NontermIdent (Map NontermIdent [Expression]))
rule97 Map NontermIdent (Map NontermIdent [Expression])
_prodsIaugmentsOut NontermIdent
arg_nt_ in
         let _lhsOaugmentsOut :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut = forall a. a -> a
rule101 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_augmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule102 Seq Error
_prodsIerrors in
         let _lhsOoutput :: Nonterminal
             !_lhsOoutput :: Nonterminal
_lhsOoutput = Attributes
-> Productions
-> Attributes
-> NontermIdent
-> [NontermIdent]
-> Attributes
-> Nonterminal
rule99 Attributes
_extraInh Productions
_prodsIoutput Attributes
arg_inh_ NontermIdent
arg_nt_ [NontermIdent]
arg_params_ Attributes
arg_syn_ in
         let !__result_ :: T_Nonterminal_vOut7
__result_ = AttrMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error
-> Map NontermIdent Attributes
-> Nonterminal
-> Map NontermIdent Attributes
-> T_Nonterminal_vOut7
T_Nonterminal_vOut7 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminal
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap'
          in T_Nonterminal_vOut7
__result_ )
      v32 :: T_Nonterminal_v32 
      v32 :: T_Nonterminal_vIn32 -> T_Nonterminal_vOut32
v32 = \ !(T_Nonterminal_vIn32
T_Nonterminal_vIn32 ) -> (
         let !_prodsX24 :: T_Productions_s24
_prodsX24 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s24
attach_T_Productions (T_Productions
arg_prods_)) in
         let !_prodsOnt :: NontermIdent
_prodsOnt = forall a. a -> a
rule95 NontermIdent
arg_nt_ in
         let _lhsOinhMap' :: Map Identifier Attributes
             !_lhsOinhMap' :: Map NontermIdent Attributes
_lhsOinhMap' = forall {a} {k}. a -> k -> Map k a
rule93 Attributes
arg_inh_ NontermIdent
arg_nt_ in
         let _lhsOsynMap' :: Map Identifier Attributes
             !_lhsOsynMap' :: Map NontermIdent Attributes
_lhsOsynMap' = forall k a. k -> a -> Map k a
rule94 NontermIdent
arg_nt_ Attributes
arg_syn_ in
         let !(T_Productions_vOut39 AttrMap
_prodsIallAttributes T_Productions_s50
_prodsX50) = T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 T_Productions_s24
_prodsX24 K_Productions_s24 T_Productions_v39
K_Productions_v39 (NontermIdent -> T_Productions_vIn39
T_Productions_vIn39 NontermIdent
_prodsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule100 AttrMap
_prodsIallAttributes in
         let !__st_ :: T_Nonterminal_s46
__st_ = T_Productions_s50 -> T_Nonterminal_s46
st46 T_Productions_s50
_prodsX50
             !__result_ :: T_Nonterminal_vOut32
__result_ = AttrMap
-> Map NontermIdent Attributes
-> Map NontermIdent Attributes
-> T_Nonterminal_s46
-> T_Nonterminal_vOut32
T_Nonterminal_vOut32 AttrMap
_lhsOallAttributes Map NontermIdent Attributes
_lhsOinhMap' Map NontermIdent Attributes
_lhsOsynMap' T_Nonterminal_s46
__st_
          in T_Nonterminal_vOut32
__result_ )
     in (forall t. K_Nonterminal_s14 t -> t) -> T_Nonterminal_s14
C_Nonterminal_s14 forall t. K_Nonterminal_s14 t -> t
k14
   {-# NOINLINE st46 #-}
   st46 :: T_Productions_s50 -> T_Nonterminal_s46
st46 = \ !T_Productions_s50
_prodsX50 -> let
      v33 :: T_Nonterminal_v33 
      v33 :: T_Nonterminal_v33
v33 = \ !(T_Nonterminal_vIn33 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_augmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_augmentsIn = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> NontermIdent -> Map NontermIdent (Map NontermIdent [Expression])
rule96 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn NontermIdent
arg_nt_ in
         let !_prodsOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_prodsOaugmentsIn = forall a. a -> a
rule104 Map NontermIdent (Map NontermIdent [Expression])
_augmentsIn in
         let !_prodsOinhMap :: Map NontermIdent Attributes
_prodsOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule106 Map NontermIdent Attributes
_lhsIinhMap in
         let !_prodsOoptions :: Options
_prodsOoptions = Options -> Options
rule108 Options
_lhsIoptions in
         let !_prodsOsynMap :: Map NontermIdent Attributes
_prodsOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule109 Map NontermIdent Attributes
_lhsIsynMap in
         let !_prodsOforcedIrrefutables :: AttrMap
_prodsOforcedIrrefutables = AttrMap -> AttrMap
rule105 AttrMap
_lhsIforcedIrrefutables in
         let !_extraInh :: Attributes
_extraInh = String -> Options -> Attributes
rule98 String
_lhsImainName Options
_lhsIoptions in
         let !(T_Productions_vOut40 Map NontermIdent (Map NontermIdent [Expression])
_prodsIaugmentsOut Seq Error
_prodsIerrors Productions
_prodsIoutput) = T_Productions_s50 -> T_Productions_v40
inv_Productions_s50 T_Productions_s50
_prodsX50 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> Options
-> Map NontermIdent Attributes
-> T_Productions_vIn40
T_Productions_vIn40 Map NontermIdent (Map NontermIdent [Expression])
_prodsOaugmentsIn AttrMap
_prodsOforcedIrrefutables Map NontermIdent Attributes
_prodsOinhMap Options
_prodsOoptions Map NontermIdent Attributes
_prodsOsynMap) in
         let !_augmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_augmentsOut = forall {k}.
Map NontermIdent (Map NontermIdent [Expression])
-> k -> Map k (Map NontermIdent (Map NontermIdent [Expression]))
rule97 Map NontermIdent (Map NontermIdent [Expression])
_prodsIaugmentsOut NontermIdent
arg_nt_ in
         let _lhsOaugmentsOut :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut = forall a. a -> a
rule101 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_augmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule102 Seq Error
_prodsIerrors in
         let _lhsOoutput :: Nonterminal
             !_lhsOoutput :: Nonterminal
_lhsOoutput = Attributes
-> Productions
-> Attributes
-> NontermIdent
-> [NontermIdent]
-> Attributes
-> Nonterminal
rule99 Attributes
_extraInh Productions
_prodsIoutput Attributes
arg_inh_ NontermIdent
arg_nt_ [NontermIdent]
arg_params_ Attributes
arg_syn_ in
         let !__result_ :: T_Nonterminal_vOut33
__result_ = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error -> Nonterminal -> T_Nonterminal_vOut33
T_Nonterminal_vOut33 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Nonterminal
_lhsOoutput
          in T_Nonterminal_vOut33
__result_ )
     in T_Nonterminal_v33 -> T_Nonterminal_s46
C_Nonterminal_s46 T_Nonterminal_v33
v33
   {-# NOINLINE[1] rule93 #-}
   {-# LINE 7 "src-ag/DistChildAttr.ag" #-}
   rule93 = \ !inh_ !nt_ ->
                                 {-# LINE 7 "src-ag/DistChildAttr.ag" #-}
                                 Map.singleton nt_ inh_
                                 {-# LINE 1500 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule94 #-}
   {-# LINE 8 "src-ag/DistChildAttr.ag" #-}
   rule94 = \ !nt_ !syn_ ->
                                 {-# LINE 8 "src-ag/DistChildAttr.ag" #-}
                                 Map.singleton nt_ syn_
                                 {-# LINE 1506 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule95 #-}
   {-# LINE 157 "src-ag/Desugar.ag" #-}
   rule95 = \ !nt_ ->
                   {-# LINE 157 "src-ag/Desugar.ag" #-}
                   nt_
                   {-# LINE 1512 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule96 #-}
   {-# LINE 239 "src-ag/Desugar.ag" #-}
   rule96 = \ ((!_lhsIaugmentsIn) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !nt_ ->
                         {-# LINE 239 "src-ag/Desugar.ag" #-}
                         Map.findWithDefault Map.empty nt_ _lhsIaugmentsIn
                         {-# LINE 1518 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule97 #-}
   {-# LINE 240 "src-ag/Desugar.ag" #-}
   rule97 = \ ((!_prodsIaugmentsOut) :: Map ConstructorIdent (Map Identifier [Expression])) !nt_ ->
                          {-# LINE 240 "src-ag/Desugar.ag" #-}
                          Map.singleton nt_ _prodsIaugmentsOut
                          {-# LINE 1524 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule98 #-}
   {-# LINE 292 "src-ag/Desugar.ag" #-}
   rule98 = \ ((!_lhsImainName) :: String) ((!_lhsIoptions) :: Options) ->
                   {-# LINE 292 "src-ag/Desugar.ag" #-}
                   addLateAttr _lhsIoptions _lhsImainName
                   {-# LINE 1530 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule99 #-}
   {-# LINE 308 "src-ag/Desugar.ag" #-}
   rule99 = \ !_extraInh ((!_prodsIoutput) :: Productions) !inh_ !nt_ !params_ !syn_ ->
                 {-# LINE 308 "src-ag/Desugar.ag" #-}
                 Nonterminal
                   nt_ params_
                   (_extraInh     `Map.union` inh_)
                   syn_
                   _prodsIoutput
                 {-# LINE 1540 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule100 #-}
   rule100 = \ ((!_prodsIallAttributes) :: AttrMap) ->
     _prodsIallAttributes
   {-# NOINLINE[1] rule101 #-}
   rule101 = \ !_augmentsOut ->
     _augmentsOut
   {-# NOINLINE[1] rule102 #-}
   rule102 = \ ((!_prodsIerrors) :: Seq Error) ->
     _prodsIerrors
   {-# NOINLINE[1] rule104 #-}
   rule104 = \ !_augmentsIn ->
     _augmentsIn
   {-# NOINLINE[1] rule105 #-}
   rule105 = \ ((!_lhsIforcedIrrefutables) :: AttrMap) ->
     _lhsIforcedIrrefutables
   {-# NOINLINE[1] rule106 #-}
   rule106 = \ ((!_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# NOINLINE[1] rule108 #-}
   rule108 = \ ((!_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# NOINLINE[1] rule109 #-}
   rule109 = \ ((!_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap

-- Nonterminals ------------------------------------------------
-- wrapper
data Inh_Nonterminals  = Inh_Nonterminals { Inh_Nonterminals
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
augmentsIn_Inh_Nonterminals :: !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), Inh_Nonterminals -> AttrMap
forcedIrrefutables_Inh_Nonterminals :: !(AttrMap), Inh_Nonterminals -> Map NontermIdent Attributes
inhMap_Inh_Nonterminals :: !(Map Identifier Attributes), Inh_Nonterminals -> String
mainName_Inh_Nonterminals :: !(String), Inh_Nonterminals -> Options
options_Inh_Nonterminals :: !(Options), Inh_Nonterminals -> Map NontermIdent Attributes
synMap_Inh_Nonterminals :: !(Map Identifier Attributes) }
data Syn_Nonterminals  = Syn_Nonterminals { Syn_Nonterminals -> AttrMap
allAttributes_Syn_Nonterminals :: !(AttrMap), Syn_Nonterminals
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
augmentsOut_Syn_Nonterminals :: !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))), Syn_Nonterminals -> Seq Error
errors_Syn_Nonterminals :: !(Seq Error), Syn_Nonterminals -> Map NontermIdent Attributes
inhMap'_Syn_Nonterminals :: !(Map Identifier Attributes), Syn_Nonterminals -> Nonterminals
output_Syn_Nonterminals :: !(Nonterminals), Syn_Nonterminals -> Map NontermIdent Attributes
synMap'_Syn_Nonterminals :: !(Map Identifier Attributes) }
{-# INLINABLE wrap_Nonterminals #-}
wrap_Nonterminals :: T_Nonterminals  -> Inh_Nonterminals  -> (Syn_Nonterminals )
wrap_Nonterminals :: T_Nonterminals -> Inh_Nonterminals -> Syn_Nonterminals
wrap_Nonterminals !(T_Nonterminals Identity T_Nonterminals_s16
act) !(Inh_Nonterminals Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Nonterminals_s16
sem <- Identity T_Nonterminals_s16
act
        let arg8 :: T_Nonterminals_vIn8
arg8 = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminals_vIn8
T_Nonterminals_vIn8 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap
        !(T_Nonterminals_vOut8 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminals
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap') <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Nonterminals_s16 -> forall t. K_Nonterminals_s16 t -> t
inv_Nonterminals_s16 T_Nonterminals_s16
sem K_Nonterminals_s16 T_Nonterminals_v8
K_Nonterminals_v8 T_Nonterminals_vIn8
arg8)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error
-> Map NontermIdent Attributes
-> Nonterminals
-> Map NontermIdent Attributes
-> Syn_Nonterminals
Syn_Nonterminals AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminals
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap')
   )

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

-- semantic domain
newtype T_Nonterminals  = T_Nonterminals {
                                         T_Nonterminals -> Identity T_Nonterminals_s16
attach_T_Nonterminals :: Identity (T_Nonterminals_s16 )
                                         }
data T_Nonterminals_s16  where C_Nonterminals_s16 :: {
                                                     T_Nonterminals_s16 -> forall t. K_Nonterminals_s16 t -> t
inv_Nonterminals_s16 :: !(forall t. K_Nonterminals_s16  t -> t)
                                                     } -> T_Nonterminals_s16 
data T_Nonterminals_s17  = C_Nonterminals_s17
newtype T_Nonterminals_s36  = C_Nonterminals_s36 {
                                                 T_Nonterminals_s36 -> T_Nonterminals_v20
inv_Nonterminals_s36 :: (T_Nonterminals_v20 )
                                                 }
data K_Nonterminals_s16 k  where
   K_Nonterminals_v8 :: K_Nonterminals_s16  (T_Nonterminals_v8 )
   K_Nonterminals_v19 :: K_Nonterminals_s16  (T_Nonterminals_v19 )
type T_Nonterminals_v8  = (T_Nonterminals_vIn8 ) -> (T_Nonterminals_vOut8 )
data T_Nonterminals_vIn8  = T_Nonterminals_vIn8 !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(AttrMap) !(Map Identifier Attributes) !(String) !(Options) !(Map Identifier Attributes)
data T_Nonterminals_vOut8  = T_Nonterminals_vOut8 !(AttrMap) !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(Seq Error) !(Map Identifier Attributes) !(Nonterminals) !(Map Identifier Attributes)
type T_Nonterminals_v19  = (T_Nonterminals_vIn19 ) -> (T_Nonterminals_vOut19 )
data T_Nonterminals_vIn19  = T_Nonterminals_vIn19 
data T_Nonterminals_vOut19  = T_Nonterminals_vOut19 !(AttrMap) !(Map Identifier Attributes) !(Map Identifier Attributes) !(T_Nonterminals_s36 )
type T_Nonterminals_v20  = (T_Nonterminals_vIn20 ) -> (T_Nonterminals_vOut20 )
data T_Nonterminals_vIn20  = T_Nonterminals_vIn20 !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(AttrMap) !(Map Identifier Attributes) !(String) !(Options) !(Map Identifier Attributes)
data T_Nonterminals_vOut20  = T_Nonterminals_vOut20 !(Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) !(Seq Error) !(Nonterminals)
{-# NOINLINE sem_Nonterminals_Cons #-}
sem_Nonterminals_Cons :: T_Nonterminal  -> T_Nonterminals  -> T_Nonterminals 
sem_Nonterminals_Cons :: T_Nonterminal -> T_Nonterminals -> T_Nonterminals
sem_Nonterminals_Cons T_Nonterminal
arg_hd_ T_Nonterminals
arg_tl_ = Identity T_Nonterminals_s16 -> T_Nonterminals
T_Nonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminals_s16
st16) where
   {-# NOINLINE st16 #-}
   !st16 :: T_Nonterminals_s16
st16 = let
      k16 :: K_Nonterminals_s16  t -> t
      k16 :: forall t. K_Nonterminals_s16 t -> t
k16 K_Nonterminals_s16 t
K_Nonterminals_v8 = T_Nonterminals_v8
v8
      k16 K_Nonterminals_s16 t
K_Nonterminals_v19 = T_Nonterminals_v19
v19
      v8 :: T_Nonterminals_v8 
      v8 :: T_Nonterminals_v8
v8 = \ !(T_Nonterminals_vIn8 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdX14 :: T_Nonterminal_s14
_hdX14 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminal -> Identity T_Nonterminal_s14
attach_T_Nonterminal (T_Nonterminal
arg_hd_)) in
         let !_tlX16 :: T_Nonterminals_s16
_tlX16 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s16
attach_T_Nonterminals (T_Nonterminals
arg_tl_)) in
         let !_hdOaugmentsIn :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdOaugmentsIn = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule117 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule119 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule121 Options
_lhsIoptions in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule122 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOaugmentsIn :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlOaugmentsIn = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule123 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule125 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule127 Options
_lhsIoptions in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule128 Map NontermIdent Attributes
_lhsIsynMap in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule118 AttrMap
_lhsIforcedIrrefutables in
         let !_hdOmainName :: String
_hdOmainName = String -> String
rule120 String
_lhsImainName in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule124 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOmainName :: String
_tlOmainName = String -> String
rule126 String
_lhsImainName in
         let !(T_Nonterminal_vOut7 AttrMap
_hdIallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdIaugmentsOut Seq Error
_hdIerrors Map NontermIdent Attributes
_hdIinhMap' Nonterminal
_hdIoutput Map NontermIdent Attributes
_hdIsynMap') = T_Nonterminal_s14 -> forall t. K_Nonterminal_s14 t -> t
inv_Nonterminal_s14 T_Nonterminal_s14
_hdX14 K_Nonterminal_s14 T_Nonterminal_v7
K_Nonterminal_v7 (Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminal_vIn7
T_Nonterminal_vIn7 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdOaugmentsIn AttrMap
_hdOforcedIrrefutables Map NontermIdent Attributes
_hdOinhMap String
_hdOmainName Options
_hdOoptions Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Nonterminals_vOut8 AttrMap
_tlIallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlIaugmentsOut Seq Error
_tlIerrors Map NontermIdent Attributes
_tlIinhMap' Nonterminals
_tlIoutput Map NontermIdent Attributes
_tlIsynMap') = T_Nonterminals_s16 -> forall t. K_Nonterminals_s16 t -> t
inv_Nonterminals_s16 T_Nonterminals_s16
_tlX16 K_Nonterminals_s16 T_Nonterminals_v8
K_Nonterminals_v8 (Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminals_vIn8
T_Nonterminals_vIn8 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlOaugmentsIn AttrMap
_tlOforcedIrrefutables Map NontermIdent Attributes
_tlOinhMap String
_tlOmainName Options
_tlOoptions Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule110 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOaugmentsOut :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule111 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdIaugmentsOut Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlIaugmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule112 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let _lhsOinhMap' :: Map Identifier Attributes
             !_lhsOinhMap' :: Map NontermIdent Attributes
_lhsOinhMap' = Map NontermIdent Attributes
-> Map NontermIdent Attributes -> Map NontermIdent Attributes
rule113 Map NontermIdent Attributes
_hdIinhMap' Map NontermIdent Attributes
_tlIinhMap' in
         let !_output :: Nonterminals
_output = Nonterminal -> Nonterminals -> Nonterminals
rule115 Nonterminal
_hdIoutput Nonterminals
_tlIoutput in
         let _lhsOoutput :: Nonterminals
             !_lhsOoutput :: Nonterminals
_lhsOoutput = forall a. a -> a
rule116 Nonterminals
_output in
         let _lhsOsynMap' :: Map Identifier Attributes
             !_lhsOsynMap' :: Map NontermIdent Attributes
_lhsOsynMap' = Map NontermIdent Attributes
-> Map NontermIdent Attributes -> Map NontermIdent Attributes
rule114 Map NontermIdent Attributes
_hdIsynMap' Map NontermIdent Attributes
_tlIsynMap' in
         let !__result_ :: T_Nonterminals_vOut8
__result_ = AttrMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error
-> Map NontermIdent Attributes
-> Nonterminals
-> Map NontermIdent Attributes
-> T_Nonterminals_vOut8
T_Nonterminals_vOut8 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminals
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap'
          in T_Nonterminals_vOut8
__result_ )
      v19 :: T_Nonterminals_v19 
      v19 :: T_Nonterminals_v19
v19 = \ !(T_Nonterminals_vIn19
T_Nonterminals_vIn19 ) -> (
         let !_hdX14 :: T_Nonterminal_s14
_hdX14 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminal -> Identity T_Nonterminal_s14
attach_T_Nonterminal (T_Nonterminal
arg_hd_)) in
         let !_tlX16 :: T_Nonterminals_s16
_tlX16 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Nonterminals -> Identity T_Nonterminals_s16
attach_T_Nonterminals (T_Nonterminals
arg_tl_)) in
         let !(T_Nonterminal_vOut32 AttrMap
_hdIallAttributes Map NontermIdent Attributes
_hdIinhMap' Map NontermIdent Attributes
_hdIsynMap' T_Nonterminal_s46
_hdX46) = T_Nonterminal_s14 -> forall t. K_Nonterminal_s14 t -> t
inv_Nonterminal_s14 T_Nonterminal_s14
_hdX14 K_Nonterminal_s14 (T_Nonterminal_vIn32 -> T_Nonterminal_vOut32)
K_Nonterminal_v32 (T_Nonterminal_vIn32
T_Nonterminal_vIn32 ) in
         let !(T_Nonterminals_vOut19 AttrMap
_tlIallAttributes Map NontermIdent Attributes
_tlIinhMap' Map NontermIdent Attributes
_tlIsynMap' T_Nonterminals_s36
_tlX36) = T_Nonterminals_s16 -> forall t. K_Nonterminals_s16 t -> t
inv_Nonterminals_s16 T_Nonterminals_s16
_tlX16 K_Nonterminals_s16 T_Nonterminals_v19
K_Nonterminals_v19 (T_Nonterminals_vIn19
T_Nonterminals_vIn19 ) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule110 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOinhMap' :: Map Identifier Attributes
             !_lhsOinhMap' :: Map NontermIdent Attributes
_lhsOinhMap' = Map NontermIdent Attributes
-> Map NontermIdent Attributes -> Map NontermIdent Attributes
rule113 Map NontermIdent Attributes
_hdIinhMap' Map NontermIdent Attributes
_tlIinhMap' in
         let _lhsOsynMap' :: Map Identifier Attributes
             !_lhsOsynMap' :: Map NontermIdent Attributes
_lhsOsynMap' = Map NontermIdent Attributes
-> Map NontermIdent Attributes -> Map NontermIdent Attributes
rule114 Map NontermIdent Attributes
_hdIsynMap' Map NontermIdent Attributes
_tlIsynMap' in
         let !__st_ :: T_Nonterminals_s36
__st_ = T_Nonterminal_s46 -> T_Nonterminals_s36 -> T_Nonterminals_s36
st36 T_Nonterminal_s46
_hdX46 T_Nonterminals_s36
_tlX36
             !__result_ :: T_Nonterminals_vOut19
__result_ = AttrMap
-> Map NontermIdent Attributes
-> Map NontermIdent Attributes
-> T_Nonterminals_s36
-> T_Nonterminals_vOut19
T_Nonterminals_vOut19 AttrMap
_lhsOallAttributes Map NontermIdent Attributes
_lhsOinhMap' Map NontermIdent Attributes
_lhsOsynMap' T_Nonterminals_s36
__st_
          in T_Nonterminals_vOut19
__result_ )
     in (forall t. K_Nonterminals_s16 t -> t) -> T_Nonterminals_s16
C_Nonterminals_s16 forall t. K_Nonterminals_s16 t -> t
k16
   {-# NOINLINE st36 #-}
   st36 :: T_Nonterminal_s46 -> T_Nonterminals_s36 -> T_Nonterminals_s36
st36 = \ !T_Nonterminal_s46
_hdX46 !T_Nonterminals_s36
_tlX36 -> let
      v20 :: T_Nonterminals_v20 
      v20 :: T_Nonterminals_v20
v20 = \ !(T_Nonterminals_vIn20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdOaugmentsIn :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdOaugmentsIn = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule117 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule119 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule121 Options
_lhsIoptions in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule122 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOaugmentsIn :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlOaugmentsIn = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule123 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule125 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule127 Options
_lhsIoptions in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule128 Map NontermIdent Attributes
_lhsIsynMap in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule118 AttrMap
_lhsIforcedIrrefutables in
         let !_hdOmainName :: String
_hdOmainName = String -> String
rule120 String
_lhsImainName in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule124 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOmainName :: String
_tlOmainName = String -> String
rule126 String
_lhsImainName in
         let !(T_Nonterminal_vOut33 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdIaugmentsOut Seq Error
_hdIerrors Nonterminal
_hdIoutput) = T_Nonterminal_s46 -> T_Nonterminal_v33
inv_Nonterminal_s46 T_Nonterminal_s46
_hdX46 (Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminal_vIn33
T_Nonterminal_vIn33 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdOaugmentsIn AttrMap
_hdOforcedIrrefutables Map NontermIdent Attributes
_hdOinhMap String
_hdOmainName Options
_hdOoptions Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Nonterminals_vOut20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlIaugmentsOut Seq Error
_tlIerrors Nonterminals
_tlIoutput) = T_Nonterminals_s36 -> T_Nonterminals_v20
inv_Nonterminals_s36 T_Nonterminals_s36
_tlX36 (Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> Options
-> Map NontermIdent Attributes
-> T_Nonterminals_vIn20
T_Nonterminals_vIn20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlOaugmentsIn AttrMap
_tlOforcedIrrefutables Map NontermIdent Attributes
_tlOinhMap String
_tlOmainName Options
_tlOoptions Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOaugmentsOut :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule111 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdIaugmentsOut Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlIaugmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule112 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Nonterminals
_output = Nonterminal -> Nonterminals -> Nonterminals
rule115 Nonterminal
_hdIoutput Nonterminals
_tlIoutput in
         let _lhsOoutput :: Nonterminals
             !_lhsOoutput :: Nonterminals
_lhsOoutput = forall a. a -> a
rule116 Nonterminals
_output in
         let !__result_ :: T_Nonterminals_vOut20
__result_ = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error -> Nonterminals -> T_Nonterminals_vOut20
T_Nonterminals_vOut20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Nonterminals
_lhsOoutput
          in T_Nonterminals_vOut20
__result_ )
     in T_Nonterminals_v20 -> T_Nonterminals_s36
C_Nonterminals_s36 T_Nonterminals_v20
v20
   {-# NOINLINE[1] rule110 #-}
   rule110 :: AttrMap -> AttrMap -> AttrMap
rule110 = \ ((!AttrMap
_hdIallAttributes) :: AttrMap) ((!AttrMap
_tlIallAttributes) :: AttrMap) ->
     AttrMap
_hdIallAttributes AttrMap -> AttrMap -> AttrMap
`mergeAttributes` AttrMap
_tlIallAttributes
   {-# NOINLINE[1] rule111 #-}
   rule111 :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule111 = \ ((!Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdIaugmentsOut) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ((!Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlIaugmentsOut) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
     Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_hdIaugmentsOut forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_tlIaugmentsOut
   {-# NOINLINE[1] rule112 #-}
   rule112 :: Seq Error -> Seq Error -> Seq Error
rule112 = \ ((!Seq Error
_hdIerrors) :: Seq Error) ((!Seq Error
_tlIerrors) :: Seq Error) ->
     Seq Error
_hdIerrors forall a. Seq a -> Seq a -> Seq a
Seq.>< Seq Error
_tlIerrors
   {-# NOINLINE[1] rule113 #-}
   rule113 :: Map NontermIdent Attributes
-> Map NontermIdent Attributes -> Map NontermIdent Attributes
rule113 = \ ((!Map NontermIdent Attributes
_hdIinhMap') :: Map Identifier Attributes) ((!Map NontermIdent Attributes
_tlIinhMap') :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_hdIinhMap' forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent Attributes
_tlIinhMap'
   {-# NOINLINE[1] rule114 #-}
   rule114 :: Map NontermIdent Attributes
-> Map NontermIdent Attributes -> Map NontermIdent Attributes
rule114 = \ ((!Map NontermIdent Attributes
_hdIsynMap') :: Map Identifier Attributes) ((!Map NontermIdent Attributes
_tlIsynMap') :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_hdIsynMap' forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent Attributes
_tlIsynMap'
   {-# NOINLINE[1] rule115 #-}
   rule115 :: Nonterminal -> Nonterminals -> Nonterminals
rule115 = \ ((!Nonterminal
_hdIoutput) :: Nonterminal) ((!Nonterminals
_tlIoutput) :: Nonterminals) ->
     (:) Nonterminal
_hdIoutput Nonterminals
_tlIoutput
   {-# NOINLINE[1] rule116 #-}
   rule116 :: p -> p
rule116 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule117 #-}
   rule117 :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule117 = \ ((!Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
     Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn
   {-# NOINLINE[1] rule118 #-}
   rule118 :: AttrMap -> AttrMap
rule118 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule119 #-}
   rule119 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule119 = \ ((!Map NontermIdent Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIinhMap
   {-# NOINLINE[1] rule120 #-}
   rule120 :: String -> String
rule120 = \ ((!String
_lhsImainName) :: String) ->
     String
_lhsImainName
   {-# NOINLINE[1] rule121 #-}
   rule121 :: Options -> Options
rule121 = \ ((!Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# NOINLINE[1] rule122 #-}
   rule122 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule122 = \ ((!Map NontermIdent Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIsynMap
   {-# NOINLINE[1] rule123 #-}
   rule123 :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
rule123 = \ ((!Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn) :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))) ->
     Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn
   {-# NOINLINE[1] rule124 #-}
   rule124 :: AttrMap -> AttrMap
rule124 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule125 #-}
   rule125 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule125 = \ ((!Map NontermIdent Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIinhMap
   {-# NOINLINE[1] rule126 #-}
   rule126 :: String -> String
rule126 = \ ((!String
_lhsImainName) :: String) ->
     String
_lhsImainName
   {-# NOINLINE[1] rule127 #-}
   rule127 :: Options -> Options
rule127 = \ ((!Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# NOINLINE[1] rule128 #-}
   rule128 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule128 = \ ((!Map NontermIdent Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIsynMap
{-# NOINLINE sem_Nonterminals_Nil #-}
sem_Nonterminals_Nil ::  T_Nonterminals 
sem_Nonterminals_Nil :: T_Nonterminals
sem_Nonterminals_Nil  = Identity T_Nonterminals_s16 -> T_Nonterminals
T_Nonterminals (forall (m :: * -> *) a. Monad m => a -> m a
return T_Nonterminals_s16
st16) where
   {-# NOINLINE st16 #-}
   !st16 :: T_Nonterminals_s16
st16 = let
      k16 :: K_Nonterminals_s16  t -> t
      k16 :: forall t. K_Nonterminals_s16 t -> t
k16 K_Nonterminals_s16 t
K_Nonterminals_v8 = T_Nonterminals_v8
v8
      k16 K_Nonterminals_s16 t
K_Nonterminals_v19 = T_Nonterminals_v19
v19
      v8 :: T_Nonterminals_v8 
      v8 :: T_Nonterminals_v8
v8 = \ !(T_Nonterminals_vIn8 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule129  () in
         let _lhsOaugmentsOut :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut = forall {k} {a}. () -> Map k a
rule130  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule131  () in
         let _lhsOinhMap' :: Map Identifier Attributes
             !_lhsOinhMap' :: Map NontermIdent Attributes
_lhsOinhMap' = forall {k} {a}. () -> Map k a
rule132  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule134  () in
         let _lhsOsynMap' :: Map Identifier Attributes
             !_lhsOsynMap' :: Map NontermIdent Attributes
_lhsOsynMap' = forall {k} {a}. () -> Map k a
rule133  () in
         let _lhsOoutput :: Nonterminals
             !_lhsOoutput :: Nonterminals
_lhsOoutput = forall a. a -> a
rule135 forall a. [a]
_output in
         let !__result_ :: T_Nonterminals_vOut8
__result_ = AttrMap
-> Map
     NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error
-> Map NontermIdent Attributes
-> Nonterminals
-> Map NontermIdent Attributes
-> T_Nonterminals_vOut8
T_Nonterminals_vOut8 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Map NontermIdent Attributes
_lhsOinhMap' Nonterminals
_lhsOoutput Map NontermIdent Attributes
_lhsOsynMap'
          in T_Nonterminals_vOut8
__result_ )
      v19 :: T_Nonterminals_v19 
      v19 :: T_Nonterminals_v19
v19 = \ !(T_Nonterminals_vIn19
T_Nonterminals_vIn19 ) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule129  () in
         let _lhsOinhMap' :: Map Identifier Attributes
             !_lhsOinhMap' :: Map NontermIdent Attributes
_lhsOinhMap' = forall {k} {a}. () -> Map k a
rule132  () in
         let _lhsOsynMap' :: Map Identifier Attributes
             !_lhsOsynMap' :: Map NontermIdent Attributes
_lhsOsynMap' = forall {k} {a}. () -> Map k a
rule133  () in
         let !__st_ :: T_Nonterminals_s36
__st_ = () -> T_Nonterminals_s36
st36  ()
             !__result_ :: T_Nonterminals_vOut19
__result_ = AttrMap
-> Map NontermIdent Attributes
-> Map NontermIdent Attributes
-> T_Nonterminals_s36
-> T_Nonterminals_vOut19
T_Nonterminals_vOut19 AttrMap
_lhsOallAttributes Map NontermIdent Attributes
_lhsOinhMap' Map NontermIdent Attributes
_lhsOsynMap' T_Nonterminals_s36
__st_
          in T_Nonterminals_vOut19
__result_ )
     in (forall t. K_Nonterminals_s16 t -> t) -> T_Nonterminals_s16
C_Nonterminals_s16 forall t. K_Nonterminals_s16 t -> t
k16
   {-# NOINLINE st36 #-}
   st36 :: () -> T_Nonterminals_s36
st36 = \  (()
_ :: ()) -> let
      v20 :: T_Nonterminals_v20 
      v20 :: T_Nonterminals_v20
v20 = \ !(T_Nonterminals_vIn20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOaugmentsOut :: Map NontermIdent (Map ConstructorIdent (Map Identifier [Expression]))
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut = forall {k} {a}. () -> Map k a
rule130  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule131  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule134  () in
         let _lhsOoutput :: Nonterminals
             !_lhsOoutput :: Nonterminals
_lhsOoutput = forall a. a -> a
rule135 forall a. [a]
_output in
         let !__result_ :: T_Nonterminals_vOut20
__result_ = Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
-> Seq Error -> Nonterminals -> T_Nonterminals_vOut20
T_Nonterminals_vOut20 Map NontermIdent (Map NontermIdent (Map NontermIdent [Expression]))
_lhsOaugmentsOut Seq Error
_lhsOerrors Nonterminals
_lhsOoutput
          in T_Nonterminals_vOut20
__result_ )
     in T_Nonterminals_v20 -> T_Nonterminals_s36
C_Nonterminals_s36 T_Nonterminals_v20
v20
   {-# NOINLINE[1] rule129 #-}
   rule129 :: () -> Map k a
rule129 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule130 #-}
   rule130 :: () -> Map k a
rule130 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule131 #-}
   rule131 :: () -> Seq a
rule131 = \  (()
_ :: ()) ->
     forall a. Seq a
Seq.empty
   {-# NOINLINE[1] rule132 #-}
   rule132 :: () -> Map k a
rule132 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule133 #-}
   rule133 :: () -> Map k a
rule133 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule134 #-}
   rule134 :: () -> [a]
rule134 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule135 #-}
   rule135 :: p -> p
rule135 = \ !p
_output ->
     p
_output

-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern  = Inh_Pattern { Inh_Pattern -> [(NontermIdent, NontermIdent)]
childInhs_Inh_Pattern :: !([(Identifier, Identifier)]), Inh_Pattern -> [(NontermIdent, NontermIdent)]
childSyns_Inh_Pattern :: !([(Identifier, Identifier)]), Inh_Pattern -> NontermIdent
con_Inh_Pattern :: !(ConstructorIdent), Inh_Pattern -> Set (NontermIdent, NontermIdent)
defs_Inh_Pattern :: !(Set (Identifier, Identifier)), Inh_Pattern -> AttrMap
forcedIrrefutables_Inh_Pattern :: !(AttrMap), Inh_Pattern -> NontermIdent
nt_Inh_Pattern :: !(NontermIdent) }
data Syn_Pattern  = Syn_Pattern { Syn_Pattern -> AttrMap
allAttributes_Syn_Pattern :: !(AttrMap), Syn_Pattern -> Pattern
copy_Syn_Pattern :: !(Pattern), Syn_Pattern -> Set (NontermIdent, NontermIdent)
defsCollect_Syn_Pattern :: !(Set (Identifier, Identifier)), Syn_Pattern -> Seq Error
errors_Syn_Pattern :: !(Seq Error), Syn_Pattern -> Pattern
output_Syn_Pattern :: !(Pattern) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern  -> Inh_Pattern  -> (Syn_Pattern )
wrap_Pattern :: T_Pattern -> Inh_Pattern -> Syn_Pattern
wrap_Pattern !(T_Pattern Identity T_Pattern_s18
act) !(Inh_Pattern [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Pattern_s18
sem <- Identity T_Pattern_s18
act
        let arg9 :: T_Pattern_vIn9
arg9 = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn9
T_Pattern_vIn9 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt
        !(T_Pattern_vOut9 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
sem K_Pattern_s18 T_Pattern_v9
K_Pattern_v9 T_Pattern_vIn9
arg9)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> Syn_Pattern
Syn_Pattern AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Pattern  = T_Pattern {
                               T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern :: Identity (T_Pattern_s18 )
                               }
data T_Pattern_s18  where C_Pattern_s18 :: {
                                           T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 :: !(forall t. K_Pattern_s18  t -> t)
                                           } -> T_Pattern_s18 
data T_Pattern_s19  = C_Pattern_s19
data T_Pattern_s42  = C_Pattern_s42
data T_Pattern_s45  = C_Pattern_s45
newtype T_Pattern_s51  = C_Pattern_s51 {
                                       T_Pattern_s51 -> T_Pattern_v42
inv_Pattern_s51 :: (T_Pattern_v42 )
                                       }
newtype T_Pattern_s54  = C_Pattern_s54 {
                                       T_Pattern_s54 -> T_Pattern_v48
inv_Pattern_s54 :: (T_Pattern_v48 )
                                       }
newtype T_Pattern_s58  = C_Pattern_s58 {
                                       T_Pattern_s58 -> T_Pattern_v56
inv_Pattern_s58 :: (T_Pattern_v56 )
                                       }
data K_Pattern_s18 k  where
   K_Pattern_v9 :: K_Pattern_s18  (T_Pattern_v9 )
   K_Pattern_v27 :: K_Pattern_s18  (T_Pattern_v27 )
   K_Pattern_v31 :: K_Pattern_s18  (T_Pattern_v31 )
   K_Pattern_v41 :: K_Pattern_s18  (T_Pattern_v41 )
   K_Pattern_v46 :: K_Pattern_s18  (T_Pattern_v46 )
   K_Pattern_v55 :: K_Pattern_s18  (T_Pattern_v55 )
type T_Pattern_v9  = (T_Pattern_vIn9 ) -> (T_Pattern_vOut9 )
data T_Pattern_vIn9  = T_Pattern_vIn9 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Pattern_vOut9  = T_Pattern_vOut9 !(AttrMap) !(Pattern) !(Set (Identifier, Identifier)) !(Seq Error) !(Pattern)
type T_Pattern_v27  = (T_Pattern_vIn27 ) -> (T_Pattern_vOut27 )
data T_Pattern_vIn27  = T_Pattern_vIn27 !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Pattern_vOut27  = T_Pattern_vOut27 !(AttrMap) !(Pattern) !(Set (Identifier, Identifier)) !(Seq Error) !(Pattern)
type T_Pattern_v31  = (T_Pattern_vIn31 ) -> (T_Pattern_vOut31 )
data T_Pattern_vIn31  = T_Pattern_vIn31 !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Pattern_vOut31  = T_Pattern_vOut31 !(AttrMap) !(Set (Identifier, Identifier)) !(Seq Error) !(Pattern)
type T_Pattern_v41  = (T_Pattern_vIn41 ) -> (T_Pattern_vOut41 )
data T_Pattern_vIn41  = T_Pattern_vIn41 !(ConstructorIdent) !(NontermIdent)
data T_Pattern_vOut41  = T_Pattern_vOut41 !(AttrMap) !(Set (Identifier, Identifier)) !(T_Pattern_s51 )
type T_Pattern_v42  = (T_Pattern_vIn42 ) -> (T_Pattern_vOut42 )
data T_Pattern_vIn42  = T_Pattern_vIn42 !([(Identifier, Identifier)]) !(Set (Identifier, Identifier)) !(AttrMap)
data T_Pattern_vOut42  = T_Pattern_vOut42 !(Seq Error) !(Pattern)
type T_Pattern_v46  = (T_Pattern_vIn46 ) -> (T_Pattern_vOut46 )
data T_Pattern_vIn46  = T_Pattern_vIn46 
data T_Pattern_vOut46  = T_Pattern_vOut46 !(Set (Identifier, Identifier)) !(T_Pattern_s54 )
type T_Pattern_v48  = (T_Pattern_vIn48 ) -> (T_Pattern_vOut48 )
data T_Pattern_vIn48  = T_Pattern_vIn48 !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Pattern_vOut48  = T_Pattern_vOut48 !(AttrMap) !(Seq Error) !(Pattern)
type T_Pattern_v55  = (T_Pattern_vIn55 ) -> (T_Pattern_vOut55 )
data T_Pattern_vIn55  = T_Pattern_vIn55 !(ConstructorIdent) !(NontermIdent)
data T_Pattern_vOut55  = T_Pattern_vOut55 !(AttrMap) !(T_Pattern_s58 )
type T_Pattern_v56  = (T_Pattern_vIn56 ) -> (T_Pattern_vOut56 )
data T_Pattern_vIn56  = T_Pattern_vIn56 
data T_Pattern_vOut56  = T_Pattern_vOut56 !(Set (Identifier, Identifier)) !(T_Pattern_s51 )
{-# NOINLINE sem_Pattern_Constr #-}
sem_Pattern_Constr :: (ConstructorIdent) -> T_Patterns  -> T_Pattern 
sem_Pattern_Constr :: NontermIdent -> T_Patterns -> T_Pattern
sem_Pattern_Constr !NontermIdent
arg_name_ T_Patterns
arg_pats_ = Identity T_Pattern_s18 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s18
st18) where
   {-# NOINLINE st18 #-}
   !st18 :: T_Pattern_s18
st18 = let
      k18 :: K_Pattern_s18  t -> t
      k18 :: forall t. K_Pattern_s18 t -> t
k18 K_Pattern_s18 t
K_Pattern_v9 = T_Pattern_v9
v9
      k18 K_Pattern_s18 t
K_Pattern_v27 = T_Pattern_vIn27 -> T_Pattern_vOut27
v27
      k18 K_Pattern_s18 t
K_Pattern_v31 = T_Pattern_vIn31 -> T_Pattern_vOut31
v31
      k18 K_Pattern_s18 t
K_Pattern_v41 = T_Pattern_vIn41 -> T_Pattern_vOut41
v41
      k18 K_Pattern_s18 t
K_Pattern_v46 = T_Pattern_vIn46 -> T_Pattern_vOut46
v46
      k18 K_Pattern_s18 t
K_Pattern_v55 = T_Pattern_vIn55 -> T_Pattern_vOut55
v55
      v9 :: T_Pattern_v9 
      v9 :: T_Pattern_v9
v9 = \ !(T_Pattern_vIn9 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule145 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule148 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule143 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule146 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule147 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut26 AttrMap
_patsIallAttributes Patterns
_patsIcopy Set (NontermIdent, NontermIdent)
_patsIdefsCollect Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v26
K_Patterns_v26 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn26
T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule136 AttrMap
_patsIallAttributes in
         let !_copy :: Pattern
_copy = Patterns -> NontermIdent -> Pattern
rule139 Patterns
_patsIcopy NontermIdent
arg_name_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule141 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule138 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> NontermIdent -> Pattern
rule140 Patterns
_patsIoutput NontermIdent
arg_name_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule142 Pattern
_output in
         let !__result_ :: T_Pattern_vOut9
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut9
T_Pattern_vOut9 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut9
__result_ )
      v27 :: T_Pattern_v27 
      v27 :: T_Pattern_vIn27 -> T_Pattern_vOut27
v27 = \ !(T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule145 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule148 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule143 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule146 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule147 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut26 AttrMap
_patsIallAttributes Patterns
_patsIcopy Set (NontermIdent, NontermIdent)
_patsIdefsCollect Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v26
K_Patterns_v26 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn26
T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule136 AttrMap
_patsIallAttributes in
         let !_copy :: Pattern
_copy = Patterns -> NontermIdent -> Pattern
rule139 Patterns
_patsIcopy NontermIdent
arg_name_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule141 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule138 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> NontermIdent -> Pattern
rule140 Patterns
_patsIoutput NontermIdent
arg_name_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule142 Pattern
_output in
         let !__result_ :: T_Pattern_vOut27
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut27
T_Pattern_vOut27 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut27
__result_ )
      v31 :: T_Pattern_v31 
      v31 :: T_Pattern_vIn31 -> T_Pattern_vOut31
v31 = \ !(T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule145 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule148 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule143 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule146 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule147 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut38 AttrMap
_patsIallAttributes Set (NontermIdent, NontermIdent)
_patsIdefsCollect Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v38
K_Patterns_v38 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn38
T_Patterns_vIn38 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule136 AttrMap
_patsIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule138 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> NontermIdent -> Pattern
rule140 Patterns
_patsIoutput NontermIdent
arg_name_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule142 Pattern
_output in
         let !__result_ :: T_Pattern_vOut31
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut31
T_Pattern_vOut31 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut31
__result_ )
      v41 :: T_Pattern_v41 
      v41 :: T_Pattern_vIn41 -> T_Pattern_vOut41
v41 = \ !(T_Pattern_vIn41 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule145 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule148 NontermIdent
_lhsInt in
         let !(T_Patterns_vOut45 AttrMap
_patsIallAttributes Set (NontermIdent, NontermIdent)
_patsIdefsCollect T_Patterns_s53
_patsX53) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v45
K_Patterns_v45 (NontermIdent -> NontermIdent -> T_Patterns_vIn45
T_Patterns_vIn45 NontermIdent
_patsOcon NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule136 AttrMap
_patsIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = T_Patterns_s53 -> T_Pattern_s51
st51 T_Patterns_s53
_patsX53
             !__result_ :: T_Pattern_vOut41
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Pattern_vOut41
T_Pattern_vOut41 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut41
__result_ )
      v46 :: T_Pattern_v46 
      v46 :: T_Pattern_vIn46 -> T_Pattern_vOut46
v46 = \ !(T_Pattern_vIn46
T_Pattern_vIn46 ) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !(T_Patterns_vOut51 Set (NontermIdent, NontermIdent)
_patsIdefsCollect T_Patterns_s56
_patsX56) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v51
K_Patterns_v51 (T_Patterns_vIn51
T_Patterns_vIn51 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let !__st_ :: T_Pattern_s54
__st_ = T_Patterns_s56 -> T_Pattern_s54
st54 T_Patterns_s56
_patsX56
             !__result_ :: T_Pattern_vOut46
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s54 -> T_Pattern_vOut46
T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s54
__st_
          in T_Pattern_vOut46
__result_ )
      v55 :: T_Pattern_v55 
      v55 :: T_Pattern_vIn55 -> T_Pattern_vOut55
v55 = \ !(T_Pattern_vIn55 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule145 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule148 NontermIdent
_lhsInt in
         let !(T_Patterns_vOut57 AttrMap
_patsIallAttributes T_Patterns_s59
_patsX59) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v57
K_Patterns_v57 (NontermIdent -> NontermIdent -> T_Patterns_vIn57
T_Patterns_vIn57 NontermIdent
_patsOcon NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule136 AttrMap
_patsIallAttributes in
         let !__st_ :: T_Pattern_s58
__st_ = T_Patterns_s59 -> T_Pattern_s58
st58 T_Patterns_s59
_patsX59
             !__result_ :: T_Pattern_vOut55
__result_ = AttrMap -> T_Pattern_s58 -> T_Pattern_vOut55
T_Pattern_vOut55 AttrMap
_lhsOallAttributes T_Pattern_s58
__st_
          in T_Pattern_vOut55
__result_ )
     in (forall t. K_Pattern_s18 t -> t) -> T_Pattern_s18
C_Pattern_s18 forall t. K_Pattern_s18 t -> t
k18
   {-# NOINLINE st51 #-}
   st51 :: T_Patterns_s53 -> T_Pattern_s51
st51 = \ !T_Patterns_s53
_patsX53 -> let
      v42 :: T_Pattern_v42 
      v42 :: T_Pattern_v42
v42 = \ !(T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule143 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule146 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule147 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut47 Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s53 -> T_Patterns_v47
inv_Patterns_s53 T_Patterns_s53
_patsX53 ([(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent) -> AttrMap -> T_Patterns_vIn47
T_Patterns_vIn47 [(NontermIdent, NontermIdent)]
_patsOchildInhs Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule138 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> NontermIdent -> Pattern
rule140 Patterns
_patsIoutput NontermIdent
arg_name_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule142 Pattern
_output in
         let !__result_ :: T_Pattern_vOut42
__result_ = Seq Error -> Pattern -> T_Pattern_vOut42
T_Pattern_vOut42 Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut42
__result_ )
     in T_Pattern_v42 -> T_Pattern_s51
C_Pattern_s51 T_Pattern_v42
v42
   {-# NOINLINE st54 #-}
   st54 :: T_Patterns_s56 -> T_Pattern_s54
st54 = \ !T_Patterns_s56
_patsX56 -> let
      v48 :: T_Pattern_v48 
      v48 :: T_Pattern_v48
v48 = \ !(T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule145 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule148 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule143 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule146 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule147 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut52 AttrMap
_patsIallAttributes Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s56 -> T_Patterns_v52
inv_Patterns_s56 T_Patterns_s56
_patsX56 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn52
T_Patterns_vIn52 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule136 AttrMap
_patsIallAttributes in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule138 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> NontermIdent -> Pattern
rule140 Patterns
_patsIoutput NontermIdent
arg_name_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule142 Pattern
_output in
         let !__result_ :: T_Pattern_vOut48
__result_ = AttrMap -> Seq Error -> Pattern -> T_Pattern_vOut48
T_Pattern_vOut48 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut48
__result_ )
     in T_Pattern_v48 -> T_Pattern_s54
C_Pattern_s54 T_Pattern_v48
v48
   {-# NOINLINE st58 #-}
   st58 :: T_Patterns_s59 -> T_Pattern_s58
st58 = \ !T_Patterns_s59
_patsX59 -> let
      v56 :: T_Pattern_v56 
      v56 :: T_Pattern_v56
v56 = \ !(T_Pattern_vIn56
T_Pattern_vIn56 ) -> (
         let !(T_Patterns_vOut58 Set (NontermIdent, NontermIdent)
_patsIdefsCollect T_Patterns_s53
_patsX53) = T_Patterns_s59 -> T_Patterns_v58
inv_Patterns_s59 T_Patterns_s59
_patsX59 (T_Patterns_vIn58
T_Patterns_vIn58 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = T_Patterns_s53 -> T_Pattern_s51
st51 T_Patterns_s53
_patsX53
             !__result_ :: T_Pattern_vOut56
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s51 -> T_Pattern_vOut56
T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut56
__result_ )
     in T_Pattern_v56 -> T_Pattern_s58
C_Pattern_s58 T_Pattern_v56
v56
   {-# NOINLINE[1] rule136 #-}
   rule136 :: AttrMap -> AttrMap
rule136 = \ ((!AttrMap
_patsIallAttributes) :: AttrMap) ->
     AttrMap
_patsIallAttributes
   {-# NOINLINE[1] rule137 #-}
   rule137 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule137 = \ ((!Set (NontermIdent, NontermIdent)
_patsIdefsCollect) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_patsIdefsCollect
   {-# NOINLINE[1] rule138 #-}
   rule138 :: Seq Error -> Seq Error
rule138 = \ ((!Seq Error
_patsIerrors) :: Seq Error) ->
     Seq Error
_patsIerrors
   {-# NOINLINE[1] rule139 #-}
   rule139 :: Patterns -> NontermIdent -> Pattern
rule139 = \ ((!Patterns
_patsIcopy) :: Patterns) !NontermIdent
name_ ->
     NontermIdent -> Patterns -> Pattern
Constr NontermIdent
name_ Patterns
_patsIcopy
   {-# NOINLINE[1] rule140 #-}
   rule140 :: Patterns -> NontermIdent -> Pattern
rule140 = \ ((!Patterns
_patsIoutput) :: Patterns) !NontermIdent
name_ ->
     NontermIdent -> Patterns -> Pattern
Constr NontermIdent
name_ Patterns
_patsIoutput
   {-# NOINLINE[1] rule141 #-}
   rule141 :: p -> p
rule141 = \ !p
_copy ->
     p
_copy
   {-# NOINLINE[1] rule142 #-}
   rule142 :: p -> p
rule142 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule143 #-}
   rule143 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule143 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildInhs
   {-# NOINLINE[1] rule145 #-}
   rule145 :: NontermIdent -> NontermIdent
rule145 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule146 #-}
   rule146 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule146 = \ ((!Set (NontermIdent, NontermIdent)
_lhsIdefs) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_lhsIdefs
   {-# NOINLINE[1] rule147 #-}
   rule147 :: AttrMap -> AttrMap
rule147 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule148 #-}
   rule148 :: NontermIdent -> NontermIdent
rule148 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
{-# NOINLINE sem_Pattern_Product #-}
sem_Pattern_Product :: (Pos) -> T_Patterns  -> T_Pattern 
sem_Pattern_Product :: Pos -> T_Patterns -> T_Pattern
sem_Pattern_Product !Pos
arg_pos_ T_Patterns
arg_pats_ = Identity T_Pattern_s18 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s18
st18) where
   {-# NOINLINE st18 #-}
   !st18 :: T_Pattern_s18
st18 = let
      k18 :: K_Pattern_s18  t -> t
      k18 :: forall t. K_Pattern_s18 t -> t
k18 K_Pattern_s18 t
K_Pattern_v9 = T_Pattern_v9
v9
      k18 K_Pattern_s18 t
K_Pattern_v27 = T_Pattern_vIn27 -> T_Pattern_vOut27
v27
      k18 K_Pattern_s18 t
K_Pattern_v31 = T_Pattern_vIn31 -> T_Pattern_vOut31
v31
      k18 K_Pattern_s18 t
K_Pattern_v41 = T_Pattern_vIn41 -> T_Pattern_vOut41
v41
      k18 K_Pattern_s18 t
K_Pattern_v46 = T_Pattern_vIn46 -> T_Pattern_vOut46
v46
      k18 K_Pattern_s18 t
K_Pattern_v55 = T_Pattern_vIn55 -> T_Pattern_vOut55
v55
      v9 :: T_Pattern_v9 
      v9 :: T_Pattern_v9
v9 = \ !(T_Pattern_vIn9 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule158 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule161 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule156 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule159 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule160 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut26 AttrMap
_patsIallAttributes Patterns
_patsIcopy Set (NontermIdent, NontermIdent)
_patsIdefsCollect Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v26
K_Patterns_v26 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn26
T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule149 AttrMap
_patsIallAttributes in
         let !_copy :: Pattern
_copy = Patterns -> Pos -> Pattern
rule152 Patterns
_patsIcopy Pos
arg_pos_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule154 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule151 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> Pos -> Pattern
rule153 Patterns
_patsIoutput Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule155 Pattern
_output in
         let !__result_ :: T_Pattern_vOut9
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut9
T_Pattern_vOut9 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut9
__result_ )
      v27 :: T_Pattern_v27 
      v27 :: T_Pattern_vIn27 -> T_Pattern_vOut27
v27 = \ !(T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule158 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule161 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule156 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule159 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule160 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut26 AttrMap
_patsIallAttributes Patterns
_patsIcopy Set (NontermIdent, NontermIdent)
_patsIdefsCollect Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v26
K_Patterns_v26 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn26
T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule149 AttrMap
_patsIallAttributes in
         let !_copy :: Pattern
_copy = Patterns -> Pos -> Pattern
rule152 Patterns
_patsIcopy Pos
arg_pos_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule154 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule151 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> Pos -> Pattern
rule153 Patterns
_patsIoutput Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule155 Pattern
_output in
         let !__result_ :: T_Pattern_vOut27
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut27
T_Pattern_vOut27 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut27
__result_ )
      v31 :: T_Pattern_v31 
      v31 :: T_Pattern_vIn31 -> T_Pattern_vOut31
v31 = \ !(T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule158 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule161 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule156 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule159 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule160 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut38 AttrMap
_patsIallAttributes Set (NontermIdent, NontermIdent)
_patsIdefsCollect Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v38
K_Patterns_v38 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn38
T_Patterns_vIn38 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule149 AttrMap
_patsIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule151 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> Pos -> Pattern
rule153 Patterns
_patsIoutput Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule155 Pattern
_output in
         let !__result_ :: T_Pattern_vOut31
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut31
T_Pattern_vOut31 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut31
__result_ )
      v41 :: T_Pattern_v41 
      v41 :: T_Pattern_vIn41 -> T_Pattern_vOut41
v41 = \ !(T_Pattern_vIn41 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule158 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule161 NontermIdent
_lhsInt in
         let !(T_Patterns_vOut45 AttrMap
_patsIallAttributes Set (NontermIdent, NontermIdent)
_patsIdefsCollect T_Patterns_s53
_patsX53) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v45
K_Patterns_v45 (NontermIdent -> NontermIdent -> T_Patterns_vIn45
T_Patterns_vIn45 NontermIdent
_patsOcon NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule149 AttrMap
_patsIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = T_Patterns_s53 -> T_Pattern_s51
st51 T_Patterns_s53
_patsX53
             !__result_ :: T_Pattern_vOut41
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Pattern_vOut41
T_Pattern_vOut41 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut41
__result_ )
      v46 :: T_Pattern_v46 
      v46 :: T_Pattern_vIn46 -> T_Pattern_vOut46
v46 = \ !(T_Pattern_vIn46
T_Pattern_vIn46 ) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !(T_Patterns_vOut51 Set (NontermIdent, NontermIdent)
_patsIdefsCollect T_Patterns_s56
_patsX56) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v51
K_Patterns_v51 (T_Patterns_vIn51
T_Patterns_vIn51 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let !__st_ :: T_Pattern_s54
__st_ = T_Patterns_s56 -> T_Pattern_s54
st54 T_Patterns_s56
_patsX56
             !__result_ :: T_Pattern_vOut46
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s54 -> T_Pattern_vOut46
T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s54
__st_
          in T_Pattern_vOut46
__result_ )
      v55 :: T_Pattern_v55 
      v55 :: T_Pattern_vIn55 -> T_Pattern_vOut55
v55 = \ !(T_Pattern_vIn55 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patsX20 :: T_Patterns_s20
_patsX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_pats_)) in
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule158 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule161 NontermIdent
_lhsInt in
         let !(T_Patterns_vOut57 AttrMap
_patsIallAttributes T_Patterns_s59
_patsX59) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_patsX20 K_Patterns_s20 T_Patterns_v57
K_Patterns_v57 (NontermIdent -> NontermIdent -> T_Patterns_vIn57
T_Patterns_vIn57 NontermIdent
_patsOcon NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule149 AttrMap
_patsIallAttributes in
         let !__st_ :: T_Pattern_s58
__st_ = T_Patterns_s59 -> T_Pattern_s58
st58 T_Patterns_s59
_patsX59
             !__result_ :: T_Pattern_vOut55
__result_ = AttrMap -> T_Pattern_s58 -> T_Pattern_vOut55
T_Pattern_vOut55 AttrMap
_lhsOallAttributes T_Pattern_s58
__st_
          in T_Pattern_vOut55
__result_ )
     in (forall t. K_Pattern_s18 t -> t) -> T_Pattern_s18
C_Pattern_s18 forall t. K_Pattern_s18 t -> t
k18
   {-# NOINLINE st51 #-}
   st51 :: T_Patterns_s53 -> T_Pattern_s51
st51 = \ !T_Patterns_s53
_patsX53 -> let
      v42 :: T_Pattern_v42 
      v42 :: T_Pattern_v42
v42 = \ !(T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule156 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule159 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule160 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut47 Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s53 -> T_Patterns_v47
inv_Patterns_s53 T_Patterns_s53
_patsX53 ([(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent) -> AttrMap -> T_Patterns_vIn47
T_Patterns_vIn47 [(NontermIdent, NontermIdent)]
_patsOchildInhs Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule151 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> Pos -> Pattern
rule153 Patterns
_patsIoutput Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule155 Pattern
_output in
         let !__result_ :: T_Pattern_vOut42
__result_ = Seq Error -> Pattern -> T_Pattern_vOut42
T_Pattern_vOut42 Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut42
__result_ )
     in T_Pattern_v42 -> T_Pattern_s51
C_Pattern_s51 T_Pattern_v42
v42
   {-# NOINLINE st54 #-}
   st54 :: T_Patterns_s56 -> T_Pattern_s54
st54 = \ !T_Patterns_s56
_patsX56 -> let
      v48 :: T_Pattern_v48 
      v48 :: T_Pattern_v48
v48 = \ !(T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patsOcon :: NontermIdent
_patsOcon = NontermIdent -> NontermIdent
rule158 NontermIdent
_lhsIcon in
         let !_patsOnt :: NontermIdent
_patsOnt = NontermIdent -> NontermIdent
rule161 NontermIdent
_lhsInt in
         let !_patsOchildInhs :: [(NontermIdent, NontermIdent)]
_patsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule156 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patsOdefs :: Set (NontermIdent, NontermIdent)
_patsOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule159 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patsOforcedIrrefutables :: AttrMap
_patsOforcedIrrefutables = AttrMap -> AttrMap
rule160 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Patterns_vOut52 AttrMap
_patsIallAttributes Seq Error
_patsIerrors Patterns
_patsIoutput) = T_Patterns_s56 -> T_Patterns_v52
inv_Patterns_s56 T_Patterns_s56
_patsX56 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn52
T_Patterns_vIn52 [(NontermIdent, NontermIdent)]
_patsOchildInhs NontermIdent
_patsOcon Set (NontermIdent, NontermIdent)
_patsOdefs AttrMap
_patsOforcedIrrefutables NontermIdent
_patsOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule149 AttrMap
_patsIallAttributes in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule151 Seq Error
_patsIerrors in
         let !_output :: Pattern
_output = Patterns -> Pos -> Pattern
rule153 Patterns
_patsIoutput Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule155 Pattern
_output in
         let !__result_ :: T_Pattern_vOut48
__result_ = AttrMap -> Seq Error -> Pattern -> T_Pattern_vOut48
T_Pattern_vOut48 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut48
__result_ )
     in T_Pattern_v48 -> T_Pattern_s54
C_Pattern_s54 T_Pattern_v48
v48
   {-# NOINLINE st58 #-}
   st58 :: T_Patterns_s59 -> T_Pattern_s58
st58 = \ !T_Patterns_s59
_patsX59 -> let
      v56 :: T_Pattern_v56 
      v56 :: T_Pattern_v56
v56 = \ !(T_Pattern_vIn56
T_Pattern_vIn56 ) -> (
         let !(T_Patterns_vOut58 Set (NontermIdent, NontermIdent)
_patsIdefsCollect T_Patterns_s53
_patsX53) = T_Patterns_s59 -> T_Patterns_v58
inv_Patterns_s59 T_Patterns_s59
_patsX59 (T_Patterns_vIn58
T_Patterns_vIn58 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 Set (NontermIdent, NontermIdent)
_patsIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = T_Patterns_s53 -> T_Pattern_s51
st51 T_Patterns_s53
_patsX53
             !__result_ :: T_Pattern_vOut56
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s51 -> T_Pattern_vOut56
T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut56
__result_ )
     in T_Pattern_v56 -> T_Pattern_s58
C_Pattern_s58 T_Pattern_v56
v56
   {-# NOINLINE[1] rule149 #-}
   rule149 :: AttrMap -> AttrMap
rule149 = \ ((!AttrMap
_patsIallAttributes) :: AttrMap) ->
     AttrMap
_patsIallAttributes
   {-# NOINLINE[1] rule150 #-}
   rule150 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule150 = \ ((!Set (NontermIdent, NontermIdent)
_patsIdefsCollect) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_patsIdefsCollect
   {-# NOINLINE[1] rule151 #-}
   rule151 :: Seq Error -> Seq Error
rule151 = \ ((!Seq Error
_patsIerrors) :: Seq Error) ->
     Seq Error
_patsIerrors
   {-# NOINLINE[1] rule152 #-}
   rule152 :: Patterns -> Pos -> Pattern
rule152 = \ ((!Patterns
_patsIcopy) :: Patterns) !Pos
pos_ ->
     Pos -> Patterns -> Pattern
Product Pos
pos_ Patterns
_patsIcopy
   {-# NOINLINE[1] rule153 #-}
   rule153 :: Patterns -> Pos -> Pattern
rule153 = \ ((!Patterns
_patsIoutput) :: Patterns) !Pos
pos_ ->
     Pos -> Patterns -> Pattern
Product Pos
pos_ Patterns
_patsIoutput
   {-# NOINLINE[1] rule154 #-}
   rule154 :: p -> p
rule154 = \ !p
_copy ->
     p
_copy
   {-# NOINLINE[1] rule155 #-}
   rule155 :: p -> p
rule155 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule156 #-}
   rule156 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule156 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildInhs
   {-# NOINLINE[1] rule158 #-}
   rule158 :: NontermIdent -> NontermIdent
rule158 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule159 #-}
   rule159 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule159 = \ ((!Set (NontermIdent, NontermIdent)
_lhsIdefs) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_lhsIdefs
   {-# NOINLINE[1] rule160 #-}
   rule160 :: AttrMap -> AttrMap
rule160 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule161 #-}
   rule161 :: NontermIdent -> NontermIdent
rule161 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
{-# NOINLINE sem_Pattern_Alias #-}
sem_Pattern_Alias :: (Identifier) -> (Identifier) -> T_Pattern  -> T_Pattern 
sem_Pattern_Alias :: NontermIdent -> NontermIdent -> T_Pattern -> T_Pattern
sem_Pattern_Alias !NontermIdent
arg_field_ !NontermIdent
arg_attr_ T_Pattern
arg_pat_ = Identity T_Pattern_s18 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s18
st18) where
   {-# NOINLINE st18 #-}
   !st18 :: T_Pattern_s18
st18 = let
      k18 :: K_Pattern_s18  t -> t
      k18 :: forall t. K_Pattern_s18 t -> t
k18 K_Pattern_s18 t
K_Pattern_v9 = T_Pattern_v9
v9
      k18 K_Pattern_s18 t
K_Pattern_v27 = T_Pattern_vIn27 -> T_Pattern_vOut27
v27
      k18 K_Pattern_s18 t
K_Pattern_v31 = T_Pattern_vIn31 -> T_Pattern_vOut31
v31
      k18 K_Pattern_s18 t
K_Pattern_v41 = T_Pattern_vIn41 -> T_Pattern_vOut41
v41
      k18 K_Pattern_s18 t
K_Pattern_v46 = T_Pattern_vIn46 -> T_Pattern_vOut46
v46
      k18 K_Pattern_s18 t
K_Pattern_v55 = T_Pattern_vIn55 -> T_Pattern_vOut55
v55
      v9 :: T_Pattern_v9 
      v9 :: T_Pattern_v9
v9 = \ !(T_Pattern_vIn9 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule174 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule177 NontermIdent
_lhsInt in
         let !_def :: Set (NontermIdent, NontermIdent)
_def = forall {b} {a}. b -> a -> Set (a, b)
rule166 NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule172 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule175 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !(!NontermIdent
_field',!Seq Error
_err1) = [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> (NontermIdent, Seq Error)
rule162 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_err2 :: Seq Error
_err2 = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Seq Error
rule163 NontermIdent
_field' NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule176 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut27 AttrMap
_patIallAttributes Pattern
_patIcopy Set (NontermIdent, NontermIdent)
_patIdefsCollect Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn27 -> T_Pattern_vOut27)
K_Pattern_v27 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn27
T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = NontermIdent
-> NontermIdent
-> AttrMap
-> NontermIdent
-> NontermIdent
-> AttrMap
rule168 NontermIdent
_lhsIcon NontermIdent
_lhsInt AttrMap
_patIallAttributes NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_copy :: Pattern
_copy = Pattern -> NontermIdent -> NontermIdent -> Pattern
rule170 Pattern
_patIcopy NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule171 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule167 Set (NontermIdent, NontermIdent)
_def Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error -> Seq Error
rule164 Seq Error
_err1 Seq Error
_err2 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = NontermIdent -> Pattern -> NontermIdent -> Pattern
rule165 NontermIdent
_field' Pattern
_patIoutput NontermIdent
arg_attr_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = NontermIdent
-> AttrMap
-> NontermIdent
-> Pattern
-> NontermIdent
-> NontermIdent
-> Pattern
rule169 NontermIdent
_lhsIcon AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Pattern
_output NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !__result_ :: T_Pattern_vOut9
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut9
T_Pattern_vOut9 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut9
__result_ )
      v27 :: T_Pattern_v27 
      v27 :: T_Pattern_vIn27 -> T_Pattern_vOut27
v27 = \ !(T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule174 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule177 NontermIdent
_lhsInt in
         let !_def :: Set (NontermIdent, NontermIdent)
_def = forall {b} {a}. b -> a -> Set (a, b)
rule166 NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule172 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule175 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !(!NontermIdent
_field',!Seq Error
_err1) = [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> (NontermIdent, Seq Error)
rule162 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_err2 :: Seq Error
_err2 = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Seq Error
rule163 NontermIdent
_field' NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule176 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut27 AttrMap
_patIallAttributes Pattern
_patIcopy Set (NontermIdent, NontermIdent)
_patIdefsCollect Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn27 -> T_Pattern_vOut27)
K_Pattern_v27 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn27
T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = NontermIdent
-> NontermIdent
-> AttrMap
-> NontermIdent
-> NontermIdent
-> AttrMap
rule168 NontermIdent
_lhsIcon NontermIdent
_lhsInt AttrMap
_patIallAttributes NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_copy :: Pattern
_copy = Pattern -> NontermIdent -> NontermIdent -> Pattern
rule170 Pattern
_patIcopy NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule171 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule167 Set (NontermIdent, NontermIdent)
_def Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error -> Seq Error
rule164 Seq Error
_err1 Seq Error
_err2 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = NontermIdent -> Pattern -> NontermIdent -> Pattern
rule165 NontermIdent
_field' Pattern
_patIoutput NontermIdent
arg_attr_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = NontermIdent
-> AttrMap
-> NontermIdent
-> Pattern
-> NontermIdent
-> NontermIdent
-> Pattern
rule169 NontermIdent
_lhsIcon AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Pattern
_output NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !__result_ :: T_Pattern_vOut27
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut27
T_Pattern_vOut27 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut27
__result_ )
      v31 :: T_Pattern_v31 
      v31 :: T_Pattern_vIn31 -> T_Pattern_vOut31
v31 = \ !(T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule174 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule177 NontermIdent
_lhsInt in
         let !_def :: Set (NontermIdent, NontermIdent)
_def = forall {b} {a}. b -> a -> Set (a, b)
rule166 NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule172 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule175 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !(!NontermIdent
_field',!Seq Error
_err1) = [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> (NontermIdent, Seq Error)
rule162 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_err2 :: Seq Error
_err2 = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Seq Error
rule163 NontermIdent
_field' NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule176 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut31 AttrMap
_patIallAttributes Set (NontermIdent, NontermIdent)
_patIdefsCollect Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn31 -> T_Pattern_vOut31)
K_Pattern_v31 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn31
T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = NontermIdent
-> NontermIdent
-> AttrMap
-> NontermIdent
-> NontermIdent
-> AttrMap
rule168 NontermIdent
_lhsIcon NontermIdent
_lhsInt AttrMap
_patIallAttributes NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule167 Set (NontermIdent, NontermIdent)
_def Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error -> Seq Error
rule164 Seq Error
_err1 Seq Error
_err2 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = NontermIdent -> Pattern -> NontermIdent -> Pattern
rule165 NontermIdent
_field' Pattern
_patIoutput NontermIdent
arg_attr_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = NontermIdent
-> AttrMap
-> NontermIdent
-> Pattern
-> NontermIdent
-> NontermIdent
-> Pattern
rule169 NontermIdent
_lhsIcon AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Pattern
_output NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !__result_ :: T_Pattern_vOut31
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut31
T_Pattern_vOut31 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut31
__result_ )
      v41 :: T_Pattern_v41 
      v41 :: T_Pattern_vIn41 -> T_Pattern_vOut41
v41 = \ !(T_Pattern_vIn41 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule174 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule177 NontermIdent
_lhsInt in
         let !_def :: Set (NontermIdent, NontermIdent)
_def = forall {b} {a}. b -> a -> Set (a, b)
rule166 NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !(T_Pattern_vOut41 AttrMap
_patIallAttributes Set (NontermIdent, NontermIdent)
_patIdefsCollect T_Pattern_s51
_patX51) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn41 -> T_Pattern_vOut41)
K_Pattern_v41 (NontermIdent -> NontermIdent -> T_Pattern_vIn41
T_Pattern_vIn41 NontermIdent
_patOcon NontermIdent
_patOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = NontermIdent
-> NontermIdent
-> AttrMap
-> NontermIdent
-> NontermIdent
-> AttrMap
rule168 NontermIdent
_lhsIcon NontermIdent
_lhsInt AttrMap
_patIallAttributes NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule167 Set (NontermIdent, NontermIdent)
_def Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s51 -> T_Pattern_s51
st51 NontermIdent
_lhsIcon NontermIdent
_lhsInt T_Pattern_s51
_patX51
             !__result_ :: T_Pattern_vOut41
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Pattern_vOut41
T_Pattern_vOut41 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut41
__result_ )
      v46 :: T_Pattern_v46 
      v46 :: T_Pattern_vIn46 -> T_Pattern_vOut46
v46 = \ !(T_Pattern_vIn46
T_Pattern_vIn46 ) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_def :: Set (NontermIdent, NontermIdent)
_def = forall {b} {a}. b -> a -> Set (a, b)
rule166 NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !(T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_patIdefsCollect T_Pattern_s54
_patX54) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn46 -> T_Pattern_vOut46)
K_Pattern_v46 (T_Pattern_vIn46
T_Pattern_vIn46 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule167 Set (NontermIdent, NontermIdent)
_def Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let !__st_ :: T_Pattern_s54
__st_ = T_Pattern_s54 -> T_Pattern_s54
st54 T_Pattern_s54
_patX54
             !__result_ :: T_Pattern_vOut46
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s54 -> T_Pattern_vOut46
T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s54
__st_
          in T_Pattern_vOut46
__result_ )
      v55 :: T_Pattern_v55 
      v55 :: T_Pattern_vIn55 -> T_Pattern_vOut55
v55 = \ !(T_Pattern_vIn55 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule174 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule177 NontermIdent
_lhsInt in
         let !(T_Pattern_vOut55 AttrMap
_patIallAttributes T_Pattern_s58
_patX58) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn55 -> T_Pattern_vOut55)
K_Pattern_v55 (NontermIdent -> NontermIdent -> T_Pattern_vIn55
T_Pattern_vIn55 NontermIdent
_patOcon NontermIdent
_patOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = NontermIdent
-> NontermIdent
-> AttrMap
-> NontermIdent
-> NontermIdent
-> AttrMap
rule168 NontermIdent
_lhsIcon NontermIdent
_lhsInt AttrMap
_patIallAttributes NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !__st_ :: T_Pattern_s58
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s58 -> T_Pattern_s58
st58 NontermIdent
_lhsIcon NontermIdent
_lhsInt T_Pattern_s58
_patX58
             !__result_ :: T_Pattern_vOut55
__result_ = AttrMap -> T_Pattern_s58 -> T_Pattern_vOut55
T_Pattern_vOut55 AttrMap
_lhsOallAttributes T_Pattern_s58
__st_
          in T_Pattern_vOut55
__result_ )
     in (forall t. K_Pattern_s18 t -> t) -> T_Pattern_s18
C_Pattern_s18 forall t. K_Pattern_s18 t -> t
k18
   {-# NOINLINE st51 #-}
   st51 :: NontermIdent -> NontermIdent -> T_Pattern_s51 -> T_Pattern_s51
st51 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ((!NontermIdent
_lhsInt) :: NontermIdent) !T_Pattern_s51
_patX51 -> let
      v42 :: T_Pattern_v42 
      v42 :: T_Pattern_v42
v42 = \ !(T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule172 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule175 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !(!NontermIdent
_field',!Seq Error
_err1) = [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> (NontermIdent, Seq Error)
rule162 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_err2 :: Seq Error
_err2 = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Seq Error
rule163 NontermIdent
_field' NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule176 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut42 Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s51 -> T_Pattern_v42
inv_Pattern_s51 T_Pattern_s51
_patX51 ([(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent) -> AttrMap -> T_Pattern_vIn42
T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_patOchildInhs Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error -> Seq Error
rule164 Seq Error
_err1 Seq Error
_err2 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = NontermIdent -> Pattern -> NontermIdent -> Pattern
rule165 NontermIdent
_field' Pattern
_patIoutput NontermIdent
arg_attr_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = NontermIdent
-> AttrMap
-> NontermIdent
-> Pattern
-> NontermIdent
-> NontermIdent
-> Pattern
rule169 NontermIdent
_lhsIcon AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Pattern
_output NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !__result_ :: T_Pattern_vOut42
__result_ = Seq Error -> Pattern -> T_Pattern_vOut42
T_Pattern_vOut42 Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut42
__result_ )
     in T_Pattern_v42 -> T_Pattern_s51
C_Pattern_s51 T_Pattern_v42
v42
   {-# NOINLINE st54 #-}
   st54 :: T_Pattern_s54 -> T_Pattern_s54
st54 = \ !T_Pattern_s54
_patX54 -> let
      v48 :: T_Pattern_v48 
      v48 :: T_Pattern_v48
v48 = \ !(T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule174 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule177 NontermIdent
_lhsInt in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule172 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule175 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !(!NontermIdent
_field',!Seq Error
_err1) = [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> (NontermIdent, Seq Error)
rule162 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_err2 :: Seq Error
_err2 = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> NontermIdent
-> NontermIdent
-> NontermIdent
-> Seq Error
rule163 NontermIdent
_field' NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs NontermIdent
_lhsInt NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule176 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut48 AttrMap
_patIallAttributes Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s54 -> T_Pattern_v48
inv_Pattern_s54 T_Pattern_s54
_patX54 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn48
T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = NontermIdent
-> NontermIdent
-> AttrMap
-> NontermIdent
-> NontermIdent
-> AttrMap
rule168 NontermIdent
_lhsIcon NontermIdent
_lhsInt AttrMap
_patIallAttributes NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error -> Seq Error
rule164 Seq Error
_err1 Seq Error
_err2 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = NontermIdent -> Pattern -> NontermIdent -> Pattern
rule165 NontermIdent
_field' Pattern
_patIoutput NontermIdent
arg_attr_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = NontermIdent
-> AttrMap
-> NontermIdent
-> Pattern
-> NontermIdent
-> NontermIdent
-> Pattern
rule169 NontermIdent
_lhsIcon AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Pattern
_output NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !__result_ :: T_Pattern_vOut48
__result_ = AttrMap -> Seq Error -> Pattern -> T_Pattern_vOut48
T_Pattern_vOut48 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut48
__result_ )
     in T_Pattern_v48 -> T_Pattern_s54
C_Pattern_s54 T_Pattern_v48
v48
   {-# NOINLINE st58 #-}
   st58 :: NontermIdent -> NontermIdent -> T_Pattern_s58 -> T_Pattern_s58
st58 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ((!NontermIdent
_lhsInt) :: NontermIdent) !T_Pattern_s58
_patX58 -> let
      v56 :: T_Pattern_v56 
      v56 :: T_Pattern_v56
v56 = \ !(T_Pattern_vIn56
T_Pattern_vIn56 ) -> (
         let !_def :: Set (NontermIdent, NontermIdent)
_def = forall {b} {a}. b -> a -> Set (a, b)
rule166 NontermIdent
arg_attr_ NontermIdent
arg_field_ in
         let !(T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_patIdefsCollect T_Pattern_s51
_patX51) = T_Pattern_s58 -> T_Pattern_v56
inv_Pattern_s58 T_Pattern_s58
_patX58 (T_Pattern_vIn56
T_Pattern_vIn56 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule167 Set (NontermIdent, NontermIdent)
_def Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s51 -> T_Pattern_s51
st51 NontermIdent
_lhsIcon NontermIdent
_lhsInt T_Pattern_s51
_patX51
             !__result_ :: T_Pattern_vOut56
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s51 -> T_Pattern_vOut56
T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut56
__result_ )
     in T_Pattern_v56 -> T_Pattern_s58
C_Pattern_s58 T_Pattern_v56
v56
   {-# NOINLINE rule162 #-}
   {-# LINE 110 "src-ag/Desugar.ag" #-}
   rule162 = \ ((!_lhsIchildInhs) :: [(Identifier, Identifier)]) ((!_lhsIcon) :: ConstructorIdent) ((!_lhsInt) :: NontermIdent) !attr_ !field_ ->
                                 {-# LINE 110 "src-ag/Desugar.ag" #-}
                                 maybeError field_ (UndefAttr _lhsInt _lhsIcon (Ident "<ANY>" (getPos field_)) attr_ True) $
                                   findField field_ attr_ _lhsIchildInhs
                                 {-# LINE 2470 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule163 #-}
   {-# LINE 112 "src-ag/Desugar.ag" #-}
   rule163 = \ !_field' ((!_lhsIcon) :: ConstructorIdent) ((!_lhsIdefs) :: Set (Identifier, Identifier)) ((!_lhsInt) :: NontermIdent) !attr_ !field_ ->
                   {-# LINE 112 "src-ag/Desugar.ag" #-}
                   if _field'     == field_
                   then Seq.empty
                   else if (_field'    , attr_) `Set.member` _lhsIdefs
                        then Seq.singleton $ DupRule _lhsInt _lhsIcon field_ attr_ _field'
                        else Seq.empty
                   {-# LINE 2480 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule164 #-}
   {-# LINE 117 "src-ag/Desugar.ag" #-}
   rule164 = \ !_err1 !_err2 ((!_patIerrors) :: Seq Error) ->
                     {-# LINE 117 "src-ag/Desugar.ag" #-}
                     _err1     Seq.>< _err2     Seq.>< _patIerrors
                     {-# LINE 2486 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule165 #-}
   {-# LINE 118 "src-ag/Desugar.ag" #-}
   rule165 = \ !_field' ((!_patIoutput) :: Pattern) !attr_ ->
                     {-# LINE 118 "src-ag/Desugar.ag" #-}
                     Alias _field'     attr_ _patIoutput
                     {-# LINE 2492 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule166 #-}
   {-# LINE 182 "src-ag/Desugar.ag" #-}
   rule166 = \ !attr_ !field_ ->
                  {-# LINE 182 "src-ag/Desugar.ag" #-}
                  Set.singleton (field_, attr_)
                  {-# LINE 2498 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule167 #-}
   {-# LINE 183 "src-ag/Desugar.ag" #-}
   rule167 = \ !_def ((!_patIdefsCollect) :: Set (Identifier, Identifier)) ->
                          {-# LINE 183 "src-ag/Desugar.ag" #-}
                          _def     `Set.union` _patIdefsCollect
                          {-# LINE 2504 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule168 #-}
   {-# LINE 200 "src-ag/Desugar.ag" #-}
   rule168 = \ ((!_lhsIcon) :: ConstructorIdent) ((!_lhsInt) :: NontermIdent) ((!_patIallAttributes) :: AttrMap) !attr_ !field_ ->
                            {-# LINE 200 "src-ag/Desugar.ag" #-}
                            (Map.singleton _lhsInt $ Map.singleton _lhsIcon $ Set.singleton (field_, attr_)) `mergeAttributes` _patIallAttributes
                            {-# LINE 2510 "src-generated/Desugar.hs" #-}
   {-# NOINLINE rule169 #-}
   {-# LINE 219 "src-ag/Desugar.ag" #-}
   rule169 = \ ((!_lhsIcon) :: ConstructorIdent) ((!_lhsIforcedIrrefutables) :: AttrMap) ((!_lhsInt) :: NontermIdent) !_output !attr_ !field_ ->
                     {-# LINE 219 "src-ag/Desugar.ag" #-}
                     if Set.member (field_, attr_) $ Map.findWithDefault Set.empty _lhsIcon $ Map.findWithDefault Map.empty _lhsInt $ _lhsIforcedIrrefutables
                     then Irrefutable _output
                     else _output
                     {-# LINE 2518 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule170 #-}
   rule170 = \ ((!_patIcopy) :: Pattern) !attr_ !field_ ->
     Alias field_ attr_ _patIcopy
   {-# NOINLINE[1] rule171 #-}
   rule171 = \ !_copy ->
     _copy
   {-# NOINLINE[1] rule172 #-}
   rule172 = \ ((!_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     _lhsIchildInhs
   {-# NOINLINE[1] rule174 #-}
   rule174 = \ ((!_lhsIcon) :: ConstructorIdent) ->
     _lhsIcon
   {-# NOINLINE[1] rule175 #-}
   rule175 = \ ((!_lhsIdefs) :: Set (Identifier, Identifier)) ->
     _lhsIdefs
   {-# NOINLINE[1] rule176 #-}
   rule176 = \ ((!_lhsIforcedIrrefutables) :: AttrMap) ->
     _lhsIforcedIrrefutables
   {-# NOINLINE[1] rule177 #-}
   rule177 = \ ((!_lhsInt) :: NontermIdent) ->
     _lhsInt
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Pattern  -> T_Pattern 
sem_Pattern_Irrefutable :: T_Pattern -> T_Pattern
sem_Pattern_Irrefutable T_Pattern
arg_pat_ = Identity T_Pattern_s18 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s18
st18) where
   {-# NOINLINE st18 #-}
   !st18 :: T_Pattern_s18
st18 = let
      k18 :: K_Pattern_s18  t -> t
      k18 :: forall t. K_Pattern_s18 t -> t
k18 K_Pattern_s18 t
K_Pattern_v9 = T_Pattern_v9
v9
      k18 K_Pattern_s18 t
K_Pattern_v27 = T_Pattern_vIn27 -> T_Pattern_vOut27
v27
      k18 K_Pattern_s18 t
K_Pattern_v31 = T_Pattern_vIn31 -> T_Pattern_vOut31
v31
      k18 K_Pattern_s18 t
K_Pattern_v41 = T_Pattern_vIn41 -> T_Pattern_vOut41
v41
      k18 K_Pattern_s18 t
K_Pattern_v46 = T_Pattern_vIn46 -> T_Pattern_vOut46
v46
      k18 K_Pattern_s18 t
K_Pattern_v55 = T_Pattern_vIn55 -> T_Pattern_vOut55
v55
      v9 :: T_Pattern_v9 
      v9 :: T_Pattern_v9
v9 = \ !(T_Pattern_vIn9 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule178  () in
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule185 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule187 NontermIdent
_lhsIcon in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule188 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule190 NontermIdent
_lhsInt in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule189 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut27 AttrMap
_patIallAttributes Pattern
_patIcopy Set (NontermIdent, NontermIdent)
_patIdefsCollect Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn27 -> T_Pattern_vOut27)
K_Pattern_v27 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn27
T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let !_copy :: Pattern
_copy = Pattern -> Pattern
rule181 Pattern
_patIcopy in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule183 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule179 Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule180 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = Pattern -> Pattern
rule182 Pattern
_patIoutput in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule184 Pattern
_output in
         let !__result_ :: T_Pattern_vOut9
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut9
T_Pattern_vOut9 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut9
__result_ )
      v27 :: T_Pattern_v27 
      v27 :: T_Pattern_vIn27 -> T_Pattern_vOut27
v27 = \ !(T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule178  () in
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule185 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule187 NontermIdent
_lhsIcon in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule188 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule190 NontermIdent
_lhsInt in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule189 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut27 AttrMap
_patIallAttributes Pattern
_patIcopy Set (NontermIdent, NontermIdent)
_patIdefsCollect Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn27 -> T_Pattern_vOut27)
K_Pattern_v27 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn27
T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let !_copy :: Pattern
_copy = Pattern -> Pattern
rule181 Pattern
_patIcopy in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule183 Pattern
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule179 Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule180 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = Pattern -> Pattern
rule182 Pattern
_patIoutput in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule184 Pattern
_output in
         let !__result_ :: T_Pattern_vOut27
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut27
T_Pattern_vOut27 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut27
__result_ )
      v31 :: T_Pattern_v31 
      v31 :: T_Pattern_vIn31 -> T_Pattern_vOut31
v31 = \ !(T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule178  () in
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule185 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule187 NontermIdent
_lhsIcon in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule188 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule190 NontermIdent
_lhsInt in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule189 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut31 AttrMap
_patIallAttributes Set (NontermIdent, NontermIdent)
_patIdefsCollect Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn31 -> T_Pattern_vOut31)
K_Pattern_v31 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn31
T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule179 Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule180 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = Pattern -> Pattern
rule182 Pattern
_patIoutput in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule184 Pattern
_output in
         let !__result_ :: T_Pattern_vOut31
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut31
T_Pattern_vOut31 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut31
__result_ )
      v41 :: T_Pattern_v41 
      v41 :: T_Pattern_vIn41 -> T_Pattern_vOut41
v41 = \ !(T_Pattern_vIn41 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule178  () in
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !(T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_patIdefsCollect T_Pattern_s54
_patX54) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn46 -> T_Pattern_vOut46)
K_Pattern_v46 (T_Pattern_vIn46
T_Pattern_vIn46 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule179 Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s54 -> T_Pattern_s51
st51 NontermIdent
_lhsIcon NontermIdent
_lhsInt T_Pattern_s54
_patX54
             !__result_ :: T_Pattern_vOut41
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Pattern_vOut41
T_Pattern_vOut41 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut41
__result_ )
      v46 :: T_Pattern_v46 
      v46 :: T_Pattern_vIn46 -> T_Pattern_vOut46
v46 = \ !(T_Pattern_vIn46
T_Pattern_vIn46 ) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !(T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_patIdefsCollect T_Pattern_s54
_patX54) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn46 -> T_Pattern_vOut46)
K_Pattern_v46 (T_Pattern_vIn46
T_Pattern_vIn46 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule179 Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let !__st_ :: T_Pattern_s54
__st_ = T_Pattern_s54 -> T_Pattern_s54
st54 T_Pattern_s54
_patX54
             !__result_ :: T_Pattern_vOut46
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s54 -> T_Pattern_vOut46
T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s54
__st_
          in T_Pattern_vOut46
__result_ )
      v55 :: T_Pattern_v55 
      v55 :: T_Pattern_vIn55 -> T_Pattern_vOut55
v55 = \ !(T_Pattern_vIn55 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule178  () in
         let !__st_ :: T_Pattern_s58
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s58
st58 NontermIdent
_lhsIcon NontermIdent
_lhsInt
             !__result_ :: T_Pattern_vOut55
__result_ = AttrMap -> T_Pattern_s58 -> T_Pattern_vOut55
T_Pattern_vOut55 AttrMap
_lhsOallAttributes T_Pattern_s58
__st_
          in T_Pattern_vOut55
__result_ )
     in (forall t. K_Pattern_s18 t -> t) -> T_Pattern_s18
C_Pattern_s18 forall t. K_Pattern_s18 t -> t
k18
   {-# NOINLINE st51 #-}
   st51 :: NontermIdent -> NontermIdent -> T_Pattern_s54 -> T_Pattern_s51
st51 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ((!NontermIdent
_lhsInt) :: NontermIdent) !T_Pattern_s54
_patX54 -> let
      v42 :: T_Pattern_v42 
      v42 :: T_Pattern_v42
v42 = \ !(T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule187 NontermIdent
_lhsIcon in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule190 NontermIdent
_lhsInt in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule185 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule188 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule189 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut48 AttrMap
_patIallAttributes Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s54 -> T_Pattern_v48
inv_Pattern_s54 T_Pattern_s54
_patX54 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn48
T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule180 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = Pattern -> Pattern
rule182 Pattern
_patIoutput in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule184 Pattern
_output in
         let !__result_ :: T_Pattern_vOut42
__result_ = Seq Error -> Pattern -> T_Pattern_vOut42
T_Pattern_vOut42 Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut42
__result_ )
     in T_Pattern_v42 -> T_Pattern_s51
C_Pattern_s51 T_Pattern_v42
v42
   {-# NOINLINE st54 #-}
   st54 :: T_Pattern_s54 -> T_Pattern_s54
st54 = \ !T_Pattern_s54
_patX54 -> let
      v48 :: T_Pattern_v48 
      v48 :: T_Pattern_v48
v48 = \ !(T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule178  () in
         let !_patOchildInhs :: [(NontermIdent, NontermIdent)]
_patOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule185 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patOcon :: NontermIdent
_patOcon = NontermIdent -> NontermIdent
rule187 NontermIdent
_lhsIcon in
         let !_patOdefs :: Set (NontermIdent, NontermIdent)
_patOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule188 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_patOnt :: NontermIdent
_patOnt = NontermIdent -> NontermIdent
rule190 NontermIdent
_lhsInt in
         let !_patOforcedIrrefutables :: AttrMap
_patOforcedIrrefutables = AttrMap -> AttrMap
rule189 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut48 AttrMap
_patIallAttributes Seq Error
_patIerrors Pattern
_patIoutput) = T_Pattern_s54 -> T_Pattern_v48
inv_Pattern_s54 T_Pattern_s54
_patX54 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn48
T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_patOchildInhs NontermIdent
_patOcon Set (NontermIdent, NontermIdent)
_patOdefs AttrMap
_patOforcedIrrefutables NontermIdent
_patOnt) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error
rule180 Seq Error
_patIerrors in
         let !_output :: Pattern
_output = Pattern -> Pattern
rule182 Pattern
_patIoutput in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule184 Pattern
_output in
         let !__result_ :: T_Pattern_vOut48
__result_ = AttrMap -> Seq Error -> Pattern -> T_Pattern_vOut48
T_Pattern_vOut48 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut48
__result_ )
     in T_Pattern_v48 -> T_Pattern_s54
C_Pattern_s54 T_Pattern_v48
v48
   {-# NOINLINE st58 #-}
   st58 :: NontermIdent -> NontermIdent -> T_Pattern_s58
st58 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ((!NontermIdent
_lhsInt) :: NontermIdent) -> let
      v56 :: T_Pattern_v56 
      v56 :: T_Pattern_v56
v56 = \ !(T_Pattern_vIn56
T_Pattern_vIn56 ) -> (
         let !_patX18 :: T_Pattern_s18
_patX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pat_)) in
         let !(T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_patIdefsCollect T_Pattern_s54
_patX54) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patX18 K_Pattern_s18 (T_Pattern_vIn46 -> T_Pattern_vOut46)
K_Pattern_v46 (T_Pattern_vIn46
T_Pattern_vIn46 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule179 Set (NontermIdent, NontermIdent)
_patIdefsCollect in
         let !__st_ :: T_Pattern_s51
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s54 -> T_Pattern_s51
st51 NontermIdent
_lhsIcon NontermIdent
_lhsInt T_Pattern_s54
_patX54
             !__result_ :: T_Pattern_vOut56
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s51 -> T_Pattern_vOut56
T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut56
__result_ )
     in T_Pattern_v56 -> T_Pattern_s58
C_Pattern_s58 T_Pattern_v56
v56
   {-# NOINLINE rule178 #-}
   {-# LINE 202 "src-ag/Desugar.ag" #-}
   rule178 = \  (_ :: ()) ->
                            {-# LINE 202 "src-ag/Desugar.ag" #-}
                            Map.empty
                            {-# LINE 2701 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule179 #-}
   rule179 = \ ((!_patIdefsCollect) :: Set (Identifier, Identifier)) ->
     _patIdefsCollect
   {-# NOINLINE[1] rule180 #-}
   rule180 = \ ((!_patIerrors) :: Seq Error) ->
     _patIerrors
   {-# NOINLINE[1] rule181 #-}
   rule181 = \ ((!_patIcopy) :: Pattern) ->
     Irrefutable _patIcopy
   {-# NOINLINE[1] rule182 #-}
   rule182 = \ ((!_patIoutput) :: Pattern) ->
     Irrefutable _patIoutput
   {-# NOINLINE[1] rule183 #-}
   rule183 = \ !_copy ->
     _copy
   {-# NOINLINE[1] rule184 #-}
   rule184 = \ !_output ->
     _output
   {-# NOINLINE[1] rule185 #-}
   rule185 = \ ((!_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     _lhsIchildInhs
   {-# NOINLINE[1] rule187 #-}
   rule187 = \ ((!_lhsIcon) :: ConstructorIdent) ->
     _lhsIcon
   {-# NOINLINE[1] rule188 #-}
   rule188 = \ ((!_lhsIdefs) :: Set (Identifier, Identifier)) ->
     _lhsIdefs
   {-# NOINLINE[1] rule189 #-}
   rule189 = \ ((!_lhsIforcedIrrefutables) :: AttrMap) ->
     _lhsIforcedIrrefutables
   {-# NOINLINE[1] rule190 #-}
   rule190 = \ ((!_lhsInt) :: NontermIdent) ->
     _lhsInt
{-# NOINLINE sem_Pattern_Underscore #-}
sem_Pattern_Underscore :: (Pos) -> T_Pattern 
sem_Pattern_Underscore :: Pos -> T_Pattern
sem_Pattern_Underscore !Pos
arg_pos_ = Identity T_Pattern_s18 -> T_Pattern
T_Pattern (forall (m :: * -> *) a. Monad m => a -> m a
return T_Pattern_s18
st18) where
   {-# NOINLINE st18 #-}
   !st18 :: T_Pattern_s18
st18 = let
      k18 :: K_Pattern_s18  t -> t
      k18 :: forall t. K_Pattern_s18 t -> t
k18 K_Pattern_s18 t
K_Pattern_v9 = T_Pattern_v9
v9
      k18 K_Pattern_s18 t
K_Pattern_v27 = T_Pattern_vIn27 -> T_Pattern_vOut27
v27
      k18 K_Pattern_s18 t
K_Pattern_v31 = T_Pattern_vIn31 -> T_Pattern_vOut31
v31
      k18 K_Pattern_s18 t
K_Pattern_v41 = T_Pattern_vIn41 -> T_Pattern_vOut41
v41
      k18 K_Pattern_s18 t
K_Pattern_v46 = T_Pattern_vIn46 -> T_Pattern_vOut46
v46
      k18 K_Pattern_s18 t
K_Pattern_v55 = T_Pattern_vIn55 -> T_Pattern_vOut55
v55
      v9 :: T_Pattern_v9 
      v9 :: T_Pattern_v9
v9 = \ !(T_Pattern_vIn9 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule191  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule192  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule193  () in
         let !_copy :: Pattern
_copy = Pos -> Pattern
rule194 Pos
arg_pos_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule196 Pattern
_copy in
         let !_output :: Pattern
_output = Pos -> Pattern
rule195 Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule197 Pattern
_output in
         let !__result_ :: T_Pattern_vOut9
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut9
T_Pattern_vOut9 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut9
__result_ )
      v27 :: T_Pattern_v27 
      v27 :: T_Pattern_vIn27 -> T_Pattern_vOut27
v27 = \ !(T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule191  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule192  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule193  () in
         let !_copy :: Pattern
_copy = Pos -> Pattern
rule194 Pos
arg_pos_ in
         let _lhsOcopy :: Pattern
             !_lhsOcopy :: Pattern
_lhsOcopy = forall a. a -> a
rule196 Pattern
_copy in
         let !_output :: Pattern
_output = Pos -> Pattern
rule195 Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule197 Pattern
_output in
         let !__result_ :: T_Pattern_vOut27
__result_ = AttrMap
-> Pattern
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut27
T_Pattern_vOut27 AttrMap
_lhsOallAttributes Pattern
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut27
__result_ )
      v31 :: T_Pattern_v31 
      v31 :: T_Pattern_vIn31 -> T_Pattern_vOut31
v31 = \ !(T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule191  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule192  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule193  () in
         let !_output :: Pattern
_output = Pos -> Pattern
rule195 Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule197 Pattern
_output in
         let !__result_ :: T_Pattern_vOut31
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Pattern
-> T_Pattern_vOut31
T_Pattern_vOut31 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut31
__result_ )
      v41 :: T_Pattern_v41 
      v41 :: T_Pattern_vIn41 -> T_Pattern_vOut41
v41 = \ !(T_Pattern_vIn41 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule191  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule192  () in
         let !__st_ :: T_Pattern_s51
__st_ = () -> T_Pattern_s51
st51  ()
             !__result_ :: T_Pattern_vOut41
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Pattern_vOut41
T_Pattern_vOut41 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut41
__result_ )
      v46 :: T_Pattern_v46 
      v46 :: T_Pattern_vIn46 -> T_Pattern_vOut46
v46 = \ !(T_Pattern_vIn46
T_Pattern_vIn46 ) -> (
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule192  () in
         let !__st_ :: T_Pattern_s54
__st_ = () -> T_Pattern_s54
st54  ()
             !__result_ :: T_Pattern_vOut46
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s54 -> T_Pattern_vOut46
T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s54
__st_
          in T_Pattern_vOut46
__result_ )
      v55 :: T_Pattern_v55 
      v55 :: T_Pattern_vIn55 -> T_Pattern_vOut55
v55 = \ !(T_Pattern_vIn55 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule191  () in
         let !__st_ :: T_Pattern_s58
__st_ = () -> T_Pattern_s58
st58  ()
             !__result_ :: T_Pattern_vOut55
__result_ = AttrMap -> T_Pattern_s58 -> T_Pattern_vOut55
T_Pattern_vOut55 AttrMap
_lhsOallAttributes T_Pattern_s58
__st_
          in T_Pattern_vOut55
__result_ )
     in (forall t. K_Pattern_s18 t -> t) -> T_Pattern_s18
C_Pattern_s18 forall t. K_Pattern_s18 t -> t
k18
   {-# NOINLINE st51 #-}
   st51 :: () -> T_Pattern_s51
st51 = \  (()
_ :: ()) -> let
      v42 :: T_Pattern_v42 
      v42 :: T_Pattern_v42
v42 = \ !(T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule193  () in
         let !_output :: Pattern
_output = Pos -> Pattern
rule195 Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule197 Pattern
_output in
         let !__result_ :: T_Pattern_vOut42
__result_ = Seq Error -> Pattern -> T_Pattern_vOut42
T_Pattern_vOut42 Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut42
__result_ )
     in T_Pattern_v42 -> T_Pattern_s51
C_Pattern_s51 T_Pattern_v42
v42
   {-# NOINLINE st54 #-}
   st54 :: () -> T_Pattern_s54
st54 = \  (()
_ :: ()) -> let
      v48 :: T_Pattern_v48 
      v48 :: T_Pattern_v48
v48 = \ !(T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule191  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule193  () in
         let !_output :: Pattern
_output = Pos -> Pattern
rule195 Pos
arg_pos_ in
         let _lhsOoutput :: Pattern
             !_lhsOoutput :: Pattern
_lhsOoutput = forall a. a -> a
rule197 Pattern
_output in
         let !__result_ :: T_Pattern_vOut48
__result_ = AttrMap -> Seq Error -> Pattern -> T_Pattern_vOut48
T_Pattern_vOut48 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Pattern
_lhsOoutput
          in T_Pattern_vOut48
__result_ )
     in T_Pattern_v48 -> T_Pattern_s54
C_Pattern_s54 T_Pattern_v48
v48
   {-# NOINLINE st58 #-}
   st58 :: () -> T_Pattern_s58
st58 = \  (()
_ :: ()) -> let
      v56 :: T_Pattern_v56 
      v56 :: T_Pattern_v56
v56 = \ !(T_Pattern_vIn56
T_Pattern_vIn56 ) -> (
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule192  () in
         let !__st_ :: T_Pattern_s51
__st_ = () -> T_Pattern_s51
st51  ()
             !__result_ :: T_Pattern_vOut56
__result_ = Set (NontermIdent, NontermIdent)
-> T_Pattern_s51 -> T_Pattern_vOut56
T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Pattern_s51
__st_
          in T_Pattern_vOut56
__result_ )
     in T_Pattern_v56 -> T_Pattern_s58
C_Pattern_s58 T_Pattern_v56
v56
   {-# NOINLINE[1] rule191 #-}
   rule191 :: () -> Map k a
rule191 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule192 #-}
   rule192 :: () -> Set a
rule192 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# NOINLINE[1] rule193 #-}
   rule193 :: () -> Seq a
rule193 = \  (()
_ :: ()) ->
     forall a. Seq a
Seq.empty
   {-# NOINLINE[1] rule194 #-}
   rule194 :: Pos -> Pattern
rule194 = \ !Pos
pos_ ->
     Pos -> Pattern
Underscore Pos
pos_
   {-# NOINLINE[1] rule195 #-}
   rule195 :: Pos -> Pattern
rule195 = \ !Pos
pos_ ->
     Pos -> Pattern
Underscore Pos
pos_
   {-# NOINLINE[1] rule196 #-}
   rule196 :: p -> p
rule196 = \ !p
_copy ->
     p
_copy
   {-# NOINLINE[1] rule197 #-}
   rule197 :: p -> p
rule197 = \ !p
_output ->
     p
_output

-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns  = Inh_Patterns { Inh_Patterns -> [(NontermIdent, NontermIdent)]
childInhs_Inh_Patterns :: !([(Identifier, Identifier)]), Inh_Patterns -> [(NontermIdent, NontermIdent)]
childSyns_Inh_Patterns :: !([(Identifier, Identifier)]), Inh_Patterns -> NontermIdent
con_Inh_Patterns :: !(ConstructorIdent), Inh_Patterns -> Set (NontermIdent, NontermIdent)
defs_Inh_Patterns :: !(Set (Identifier, Identifier)), Inh_Patterns -> AttrMap
forcedIrrefutables_Inh_Patterns :: !(AttrMap), Inh_Patterns -> NontermIdent
nt_Inh_Patterns :: !(NontermIdent) }
data Syn_Patterns  = Syn_Patterns { Syn_Patterns -> AttrMap
allAttributes_Syn_Patterns :: !(AttrMap), Syn_Patterns -> Patterns
copy_Syn_Patterns :: !(Patterns), Syn_Patterns -> Set (NontermIdent, NontermIdent)
defsCollect_Syn_Patterns :: !(Set (Identifier, Identifier)), Syn_Patterns -> Seq Error
errors_Syn_Patterns :: !(Seq Error), Syn_Patterns -> Patterns
output_Syn_Patterns :: !(Patterns) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns  -> Inh_Patterns  -> (Syn_Patterns )
wrap_Patterns :: T_Patterns -> Inh_Patterns -> Syn_Patterns
wrap_Patterns !(T_Patterns Identity T_Patterns_s20
act) !(Inh_Patterns [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Patterns_s20
sem <- Identity T_Patterns_s20
act
        let arg10 :: T_Patterns_vIn10
arg10 = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn10
T_Patterns_vIn10 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt
        !(T_Patterns_vOut10 AttrMap
_lhsOallAttributes Patterns
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
sem K_Patterns_s20 T_Patterns_v10
K_Patterns_v10 T_Patterns_vIn10
arg10)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Patterns
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> Syn_Patterns
Syn_Patterns AttrMap
_lhsOallAttributes Patterns
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Patterns  = T_Patterns {
                                 T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns :: Identity (T_Patterns_s20 )
                                 }
data T_Patterns_s20  where C_Patterns_s20 :: {
                                             T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 :: !(forall t. K_Patterns_s20  t -> t)
                                             } -> T_Patterns_s20 
data T_Patterns_s21  = C_Patterns_s21
data T_Patterns_s41  = C_Patterns_s41
data T_Patterns_s49  = C_Patterns_s49
newtype T_Patterns_s53  = C_Patterns_s53 {
                                         T_Patterns_s53 -> T_Patterns_v47
inv_Patterns_s53 :: (T_Patterns_v47 )
                                         }
newtype T_Patterns_s56  = C_Patterns_s56 {
                                         T_Patterns_s56 -> T_Patterns_v52
inv_Patterns_s56 :: (T_Patterns_v52 )
                                         }
newtype T_Patterns_s59  = C_Patterns_s59 {
                                         T_Patterns_s59 -> T_Patterns_v58
inv_Patterns_s59 :: (T_Patterns_v58 )
                                         }
data K_Patterns_s20 k  where
   K_Patterns_v10 :: K_Patterns_s20  (T_Patterns_v10 )
   K_Patterns_v26 :: K_Patterns_s20  (T_Patterns_v26 )
   K_Patterns_v38 :: K_Patterns_s20  (T_Patterns_v38 )
   K_Patterns_v45 :: K_Patterns_s20  (T_Patterns_v45 )
   K_Patterns_v51 :: K_Patterns_s20  (T_Patterns_v51 )
   K_Patterns_v57 :: K_Patterns_s20  (T_Patterns_v57 )
type T_Patterns_v10  = (T_Patterns_vIn10 ) -> (T_Patterns_vOut10 )
data T_Patterns_vIn10  = T_Patterns_vIn10 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Patterns_vOut10  = T_Patterns_vOut10 !(AttrMap) !(Patterns) !(Set (Identifier, Identifier)) !(Seq Error) !(Patterns)
type T_Patterns_v26  = (T_Patterns_vIn26 ) -> (T_Patterns_vOut26 )
data T_Patterns_vIn26  = T_Patterns_vIn26 !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Patterns_vOut26  = T_Patterns_vOut26 !(AttrMap) !(Patterns) !(Set (Identifier, Identifier)) !(Seq Error) !(Patterns)
type T_Patterns_v38  = (T_Patterns_vIn38 ) -> (T_Patterns_vOut38 )
data T_Patterns_vIn38  = T_Patterns_vIn38 !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Patterns_vOut38  = T_Patterns_vOut38 !(AttrMap) !(Set (Identifier, Identifier)) !(Seq Error) !(Patterns)
type T_Patterns_v45  = (T_Patterns_vIn45 ) -> (T_Patterns_vOut45 )
data T_Patterns_vIn45  = T_Patterns_vIn45 !(ConstructorIdent) !(NontermIdent)
data T_Patterns_vOut45  = T_Patterns_vOut45 !(AttrMap) !(Set (Identifier, Identifier)) !(T_Patterns_s53 )
type T_Patterns_v47  = (T_Patterns_vIn47 ) -> (T_Patterns_vOut47 )
data T_Patterns_vIn47  = T_Patterns_vIn47 !([(Identifier, Identifier)]) !(Set (Identifier, Identifier)) !(AttrMap)
data T_Patterns_vOut47  = T_Patterns_vOut47 !(Seq Error) !(Patterns)
type T_Patterns_v51  = (T_Patterns_vIn51 ) -> (T_Patterns_vOut51 )
data T_Patterns_vIn51  = T_Patterns_vIn51 
data T_Patterns_vOut51  = T_Patterns_vOut51 !(Set (Identifier, Identifier)) !(T_Patterns_s56 )
type T_Patterns_v52  = (T_Patterns_vIn52 ) -> (T_Patterns_vOut52 )
data T_Patterns_vIn52  = T_Patterns_vIn52 !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent)
data T_Patterns_vOut52  = T_Patterns_vOut52 !(AttrMap) !(Seq Error) !(Patterns)
type T_Patterns_v57  = (T_Patterns_vIn57 ) -> (T_Patterns_vOut57 )
data T_Patterns_vIn57  = T_Patterns_vIn57 !(ConstructorIdent) !(NontermIdent)
data T_Patterns_vOut57  = T_Patterns_vOut57 !(AttrMap) !(T_Patterns_s59 )
type T_Patterns_v58  = (T_Patterns_vIn58 ) -> (T_Patterns_vOut58 )
data T_Patterns_vIn58  = T_Patterns_vIn58 
data T_Patterns_vOut58  = T_Patterns_vOut58 !(Set (Identifier, Identifier)) !(T_Patterns_s53 )
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern  -> T_Patterns  -> T_Patterns 
sem_Patterns_Cons :: T_Pattern -> T_Patterns -> T_Patterns
sem_Patterns_Cons T_Pattern
arg_hd_ T_Patterns
arg_tl_ = Identity T_Patterns_s20 -> T_Patterns
T_Patterns (forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s20
st20) where
   {-# NOINLINE st20 #-}
   !st20 :: T_Patterns_s20
st20 = let
      k20 :: K_Patterns_s20  t -> t
      k20 :: forall t. K_Patterns_s20 t -> t
k20 K_Patterns_s20 t
K_Patterns_v10 = T_Patterns_v10
v10
      k20 K_Patterns_s20 t
K_Patterns_v26 = T_Patterns_v26
v26
      k20 K_Patterns_s20 t
K_Patterns_v38 = T_Patterns_v38
v38
      k20 K_Patterns_s20 t
K_Patterns_v45 = T_Patterns_v45
v45
      k20 K_Patterns_s20 t
K_Patterns_v51 = T_Patterns_v51
v51
      k20 K_Patterns_s20 t
K_Patterns_v57 = T_Patterns_v57
v57
      v10 :: T_Patterns_v10 
      v10 :: T_Patterns_v10
v10 = \ !(T_Patterns_vIn10 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_hdX18 :: T_Pattern_s18
_hdX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_hd_)) in
         let !_tlX20 :: T_Patterns_s20
_tlX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule207 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule210 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule213 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule216 NontermIdent
_lhsInt in
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule205 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule208 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule211 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule214 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule209 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule215 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut27 AttrMap
_hdIallAttributes Pattern
_hdIcopy Set (NontermIdent, NontermIdent)
_hdIdefsCollect Seq Error
_hdIerrors Pattern
_hdIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_hdX18 K_Pattern_s18 (T_Pattern_vIn27 -> T_Pattern_vOut27)
K_Pattern_v27 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn27
T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_hdOchildInhs NontermIdent
_hdOcon Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables NontermIdent
_hdOnt) in
         let !(T_Patterns_vOut26 AttrMap
_tlIallAttributes Patterns
_tlIcopy Set (NontermIdent, NontermIdent)
_tlIdefsCollect Seq Error
_tlIerrors Patterns
_tlIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_tlX20 K_Patterns_s20 T_Patterns_v26
K_Patterns_v26 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn26
T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_tlOchildInhs NontermIdent
_tlOcon Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule198 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let !_copy :: Patterns
_copy = Pattern -> Patterns -> Patterns
rule201 Pattern
_hdIcopy Patterns
_tlIcopy in
         let _lhsOcopy :: Patterns
             !_lhsOcopy :: Patterns
_lhsOcopy = forall a. a -> a
rule203 Patterns
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule200 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Patterns
_output = Pattern -> Patterns -> Patterns
rule202 Pattern
_hdIoutput Patterns
_tlIoutput in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule204 Patterns
_output in
         let !__result_ :: T_Patterns_vOut10
__result_ = AttrMap
-> Patterns
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> T_Patterns_vOut10
T_Patterns_vOut10 AttrMap
_lhsOallAttributes Patterns
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut10
__result_ )
      v26 :: T_Patterns_v26 
      v26 :: T_Patterns_v26
v26 = \ !(T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_hdX18 :: T_Pattern_s18
_hdX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_hd_)) in
         let !_tlX20 :: T_Patterns_s20
_tlX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule207 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule210 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule213 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule216 NontermIdent
_lhsInt in
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule205 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule208 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule211 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule214 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule209 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule215 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut27 AttrMap
_hdIallAttributes Pattern
_hdIcopy Set (NontermIdent, NontermIdent)
_hdIdefsCollect Seq Error
_hdIerrors Pattern
_hdIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_hdX18 K_Pattern_s18 (T_Pattern_vIn27 -> T_Pattern_vOut27)
K_Pattern_v27 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn27
T_Pattern_vIn27 [(NontermIdent, NontermIdent)]
_hdOchildInhs NontermIdent
_hdOcon Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables NontermIdent
_hdOnt) in
         let !(T_Patterns_vOut26 AttrMap
_tlIallAttributes Patterns
_tlIcopy Set (NontermIdent, NontermIdent)
_tlIdefsCollect Seq Error
_tlIerrors Patterns
_tlIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_tlX20 K_Patterns_s20 T_Patterns_v26
K_Patterns_v26 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn26
T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_tlOchildInhs NontermIdent
_tlOcon Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule198 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let !_copy :: Patterns
_copy = Pattern -> Patterns -> Patterns
rule201 Pattern
_hdIcopy Patterns
_tlIcopy in
         let _lhsOcopy :: Patterns
             !_lhsOcopy :: Patterns
_lhsOcopy = forall a. a -> a
rule203 Patterns
_copy in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule200 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Patterns
_output = Pattern -> Patterns -> Patterns
rule202 Pattern
_hdIoutput Patterns
_tlIoutput in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule204 Patterns
_output in
         let !__result_ :: T_Patterns_vOut26
__result_ = AttrMap
-> Patterns
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> T_Patterns_vOut26
T_Patterns_vOut26 AttrMap
_lhsOallAttributes Patterns
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut26
__result_ )
      v38 :: T_Patterns_v38 
      v38 :: T_Patterns_v38
v38 = \ !(T_Patterns_vIn38 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_hdX18 :: T_Pattern_s18
_hdX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_hd_)) in
         let !_tlX20 :: T_Patterns_s20
_tlX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule207 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule210 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule213 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule216 NontermIdent
_lhsInt in
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule205 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule208 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule211 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule214 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule209 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule215 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut31 AttrMap
_hdIallAttributes Set (NontermIdent, NontermIdent)
_hdIdefsCollect Seq Error
_hdIerrors Pattern
_hdIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_hdX18 K_Pattern_s18 (T_Pattern_vIn31 -> T_Pattern_vOut31)
K_Pattern_v31 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn31
T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_hdOchildInhs NontermIdent
_hdOcon Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables NontermIdent
_hdOnt) in
         let !(T_Patterns_vOut38 AttrMap
_tlIallAttributes Set (NontermIdent, NontermIdent)
_tlIdefsCollect Seq Error
_tlIerrors Patterns
_tlIoutput) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_tlX20 K_Patterns_s20 T_Patterns_v38
K_Patterns_v38 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn38
T_Patterns_vIn38 [(NontermIdent, NontermIdent)]
_tlOchildInhs NontermIdent
_tlOcon Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule198 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule200 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Patterns
_output = Pattern -> Patterns -> Patterns
rule202 Pattern
_hdIoutput Patterns
_tlIoutput in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule204 Patterns
_output in
         let !__result_ :: T_Patterns_vOut38
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> T_Patterns_vOut38
T_Patterns_vOut38 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut38
__result_ )
      v45 :: T_Patterns_v45 
      v45 :: T_Patterns_v45
v45 = \ !(T_Patterns_vIn45 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_hdX18 :: T_Pattern_s18
_hdX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_hd_)) in
         let !_tlX20 :: T_Patterns_s20
_tlX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule207 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule210 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule213 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule216 NontermIdent
_lhsInt in
         let !(T_Pattern_vOut41 AttrMap
_hdIallAttributes Set (NontermIdent, NontermIdent)
_hdIdefsCollect T_Pattern_s51
_hdX51) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_hdX18 K_Pattern_s18 (T_Pattern_vIn41 -> T_Pattern_vOut41)
K_Pattern_v41 (NontermIdent -> NontermIdent -> T_Pattern_vIn41
T_Pattern_vIn41 NontermIdent
_hdOcon NontermIdent
_hdOnt) in
         let !(T_Patterns_vOut45 AttrMap
_tlIallAttributes Set (NontermIdent, NontermIdent)
_tlIdefsCollect T_Patterns_s53
_tlX53) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_tlX20 K_Patterns_s20 T_Patterns_v45
K_Patterns_v45 (NontermIdent -> NontermIdent -> T_Patterns_vIn45
T_Patterns_vIn45 NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule198 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let !__st_ :: T_Patterns_s53
__st_ = T_Pattern_s51 -> T_Patterns_s53 -> T_Patterns_s53
st53 T_Pattern_s51
_hdX51 T_Patterns_s53
_tlX53
             !__result_ :: T_Patterns_vOut45
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Patterns_s53
-> T_Patterns_vOut45
T_Patterns_vOut45 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Patterns_s53
__st_
          in T_Patterns_vOut45
__result_ )
      v51 :: T_Patterns_v51 
      v51 :: T_Patterns_v51
v51 = \ !(T_Patterns_vIn51
T_Patterns_vIn51 ) -> (
         let !_hdX18 :: T_Pattern_s18
_hdX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_hd_)) in
         let !_tlX20 :: T_Patterns_s20
_tlX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_tl_)) in
         let !(T_Pattern_vOut46 Set (NontermIdent, NontermIdent)
_hdIdefsCollect T_Pattern_s54
_hdX54) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_hdX18 K_Pattern_s18 (T_Pattern_vIn46 -> T_Pattern_vOut46)
K_Pattern_v46 (T_Pattern_vIn46
T_Pattern_vIn46 ) in
         let !(T_Patterns_vOut51 Set (NontermIdent, NontermIdent)
_tlIdefsCollect T_Patterns_s56
_tlX56) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_tlX20 K_Patterns_s20 T_Patterns_v51
K_Patterns_v51 (T_Patterns_vIn51
T_Patterns_vIn51 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let !__st_ :: T_Patterns_s56
__st_ = T_Pattern_s54 -> T_Patterns_s56 -> T_Patterns_s56
st56 T_Pattern_s54
_hdX54 T_Patterns_s56
_tlX56
             !__result_ :: T_Patterns_vOut51
__result_ = Set (NontermIdent, NontermIdent)
-> T_Patterns_s56 -> T_Patterns_vOut51
T_Patterns_vOut51 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Patterns_s56
__st_
          in T_Patterns_vOut51
__result_ )
      v57 :: T_Patterns_v57 
      v57 :: T_Patterns_v57
v57 = \ !(T_Patterns_vIn57 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_hdX18 :: T_Pattern_s18
_hdX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_hd_)) in
         let !_tlX20 :: T_Patterns_s20
_tlX20 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Patterns -> Identity T_Patterns_s20
attach_T_Patterns (T_Patterns
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule207 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule210 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule213 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule216 NontermIdent
_lhsInt in
         let !(T_Pattern_vOut55 AttrMap
_hdIallAttributes T_Pattern_s58
_hdX58) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_hdX18 K_Pattern_s18 (T_Pattern_vIn55 -> T_Pattern_vOut55)
K_Pattern_v55 (NontermIdent -> NontermIdent -> T_Pattern_vIn55
T_Pattern_vIn55 NontermIdent
_hdOcon NontermIdent
_hdOnt) in
         let !(T_Patterns_vOut57 AttrMap
_tlIallAttributes T_Patterns_s59
_tlX59) = T_Patterns_s20 -> forall t. K_Patterns_s20 t -> t
inv_Patterns_s20 T_Patterns_s20
_tlX20 K_Patterns_s20 T_Patterns_v57
K_Patterns_v57 (NontermIdent -> NontermIdent -> T_Patterns_vIn57
T_Patterns_vIn57 NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule198 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let !__st_ :: T_Patterns_s59
__st_ = T_Pattern_s58 -> T_Patterns_s59 -> T_Patterns_s59
st59 T_Pattern_s58
_hdX58 T_Patterns_s59
_tlX59
             !__result_ :: T_Patterns_vOut57
__result_ = AttrMap -> T_Patterns_s59 -> T_Patterns_vOut57
T_Patterns_vOut57 AttrMap
_lhsOallAttributes T_Patterns_s59
__st_
          in T_Patterns_vOut57
__result_ )
     in (forall t. K_Patterns_s20 t -> t) -> T_Patterns_s20
C_Patterns_s20 forall t. K_Patterns_s20 t -> t
k20
   {-# NOINLINE st53 #-}
   st53 :: T_Pattern_s51 -> T_Patterns_s53 -> T_Patterns_s53
st53 = \ !T_Pattern_s51
_hdX51 !T_Patterns_s53
_tlX53 -> let
      v47 :: T_Patterns_v47 
      v47 :: T_Patterns_v47
v47 = \ !(T_Patterns_vIn47 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule205 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule208 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule211 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule214 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule209 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule215 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut42 Seq Error
_hdIerrors Pattern
_hdIoutput) = T_Pattern_s51 -> T_Pattern_v42
inv_Pattern_s51 T_Pattern_s51
_hdX51 ([(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent) -> AttrMap -> T_Pattern_vIn42
T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_hdOchildInhs Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables) in
         let !(T_Patterns_vOut47 Seq Error
_tlIerrors Patterns
_tlIoutput) = T_Patterns_s53 -> T_Patterns_v47
inv_Patterns_s53 T_Patterns_s53
_tlX53 ([(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent) -> AttrMap -> T_Patterns_vIn47
T_Patterns_vIn47 [(NontermIdent, NontermIdent)]
_tlOchildInhs Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule200 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Patterns
_output = Pattern -> Patterns -> Patterns
rule202 Pattern
_hdIoutput Patterns
_tlIoutput in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule204 Patterns
_output in
         let !__result_ :: T_Patterns_vOut47
__result_ = Seq Error -> Patterns -> T_Patterns_vOut47
T_Patterns_vOut47 Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut47
__result_ )
     in T_Patterns_v47 -> T_Patterns_s53
C_Patterns_s53 T_Patterns_v47
v47
   {-# NOINLINE st56 #-}
   st56 :: T_Pattern_s54 -> T_Patterns_s56 -> T_Patterns_s56
st56 = \ !T_Pattern_s54
_hdX54 !T_Patterns_s56
_tlX56 -> let
      v52 :: T_Patterns_v52 
      v52 :: T_Patterns_v52
v52 = \ !(T_Patterns_vIn52 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule207 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule210 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule213 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule216 NontermIdent
_lhsInt in
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule205 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule208 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule211 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule214 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule209 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule215 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut48 AttrMap
_hdIallAttributes Seq Error
_hdIerrors Pattern
_hdIoutput) = T_Pattern_s54 -> T_Pattern_v48
inv_Pattern_s54 T_Pattern_s54
_hdX54 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn48
T_Pattern_vIn48 [(NontermIdent, NontermIdent)]
_hdOchildInhs NontermIdent
_hdOcon Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables NontermIdent
_hdOnt) in
         let !(T_Patterns_vOut52 AttrMap
_tlIallAttributes Seq Error
_tlIerrors Patterns
_tlIoutput) = T_Patterns_s56 -> T_Patterns_v52
inv_Patterns_s56 T_Patterns_s56
_tlX56 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Patterns_vIn52
T_Patterns_vIn52 [(NontermIdent, NontermIdent)]
_tlOchildInhs NontermIdent
_tlOcon Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule198 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule200 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Patterns
_output = Pattern -> Patterns -> Patterns
rule202 Pattern
_hdIoutput Patterns
_tlIoutput in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule204 Patterns
_output in
         let !__result_ :: T_Patterns_vOut52
__result_ = AttrMap -> Seq Error -> Patterns -> T_Patterns_vOut52
T_Patterns_vOut52 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut52
__result_ )
     in T_Patterns_v52 -> T_Patterns_s56
C_Patterns_s56 T_Patterns_v52
v52
   {-# NOINLINE st59 #-}
   st59 :: T_Pattern_s58 -> T_Patterns_s59 -> T_Patterns_s59
st59 = \ !T_Pattern_s58
_hdX58 !T_Patterns_s59
_tlX59 -> let
      v58 :: T_Patterns_v58 
      v58 :: T_Patterns_v58
v58 = \ !(T_Patterns_vIn58
T_Patterns_vIn58 ) -> (
         let !(T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_hdIdefsCollect T_Pattern_s51
_hdX51) = T_Pattern_s58 -> T_Pattern_v56
inv_Pattern_s58 T_Pattern_s58
_hdX58 (T_Pattern_vIn56
T_Pattern_vIn56 ) in
         let !(T_Patterns_vOut58 Set (NontermIdent, NontermIdent)
_tlIdefsCollect T_Patterns_s53
_tlX53) = T_Patterns_s59 -> T_Patterns_v58
inv_Patterns_s59 T_Patterns_s59
_tlX59 (T_Patterns_vIn58
T_Patterns_vIn58 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let !__st_ :: T_Patterns_s53
__st_ = T_Pattern_s51 -> T_Patterns_s53 -> T_Patterns_s53
st53 T_Pattern_s51
_hdX51 T_Patterns_s53
_tlX53
             !__result_ :: T_Patterns_vOut58
__result_ = Set (NontermIdent, NontermIdent)
-> T_Patterns_s53 -> T_Patterns_vOut58
T_Patterns_vOut58 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Patterns_s53
__st_
          in T_Patterns_vOut58
__result_ )
     in T_Patterns_v58 -> T_Patterns_s59
C_Patterns_s59 T_Patterns_v58
v58
   {-# NOINLINE[1] rule198 #-}
   rule198 :: AttrMap -> AttrMap -> AttrMap
rule198 = \ ((!AttrMap
_hdIallAttributes) :: AttrMap) ((!AttrMap
_tlIallAttributes) :: AttrMap) ->
     AttrMap
_hdIallAttributes AttrMap -> AttrMap -> AttrMap
`mergeAttributes` AttrMap
_tlIallAttributes
   {-# NOINLINE[1] rule199 #-}
   rule199 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule199 = \ ((!Set (NontermIdent, NontermIdent)
_hdIdefsCollect) :: Set (Identifier, Identifier)) ((!Set (NontermIdent, NontermIdent)
_tlIdefsCollect) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_hdIdefsCollect forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set (NontermIdent, NontermIdent)
_tlIdefsCollect
   {-# NOINLINE[1] rule200 #-}
   rule200 :: Seq Error -> Seq Error -> Seq Error
rule200 = \ ((!Seq Error
_hdIerrors) :: Seq Error) ((!Seq Error
_tlIerrors) :: Seq Error) ->
     Seq Error
_hdIerrors forall a. Seq a -> Seq a -> Seq a
Seq.>< Seq Error
_tlIerrors
   {-# NOINLINE[1] rule201 #-}
   rule201 :: Pattern -> Patterns -> Patterns
rule201 = \ ((!Pattern
_hdIcopy) :: Pattern) ((!Patterns
_tlIcopy) :: Patterns) ->
     (:) Pattern
_hdIcopy Patterns
_tlIcopy
   {-# NOINLINE[1] rule202 #-}
   rule202 :: Pattern -> Patterns -> Patterns
rule202 = \ ((!Pattern
_hdIoutput) :: Pattern) ((!Patterns
_tlIoutput) :: Patterns) ->
     (:) Pattern
_hdIoutput Patterns
_tlIoutput
   {-# NOINLINE[1] rule203 #-}
   rule203 :: p -> p
rule203 = \ !p
_copy ->
     p
_copy
   {-# NOINLINE[1] rule204 #-}
   rule204 :: p -> p
rule204 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule205 #-}
   rule205 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule205 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildInhs
   {-# NOINLINE[1] rule207 #-}
   rule207 :: NontermIdent -> NontermIdent
rule207 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule208 #-}
   rule208 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule208 = \ ((!Set (NontermIdent, NontermIdent)
_lhsIdefs) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_lhsIdefs
   {-# NOINLINE[1] rule209 #-}
   rule209 :: AttrMap -> AttrMap
rule209 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule210 #-}
   rule210 :: NontermIdent -> NontermIdent
rule210 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule211 #-}
   rule211 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule211 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildInhs
   {-# NOINLINE[1] rule213 #-}
   rule213 :: NontermIdent -> NontermIdent
rule213 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule214 #-}
   rule214 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule214 = \ ((!Set (NontermIdent, NontermIdent)
_lhsIdefs) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_lhsIdefs
   {-# NOINLINE[1] rule215 #-}
   rule215 :: AttrMap -> AttrMap
rule215 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule216 #-}
   rule216 :: NontermIdent -> NontermIdent
rule216 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil ::  T_Patterns 
sem_Patterns_Nil :: T_Patterns
sem_Patterns_Nil  = Identity T_Patterns_s20 -> T_Patterns
T_Patterns (forall (m :: * -> *) a. Monad m => a -> m a
return T_Patterns_s20
st20) where
   {-# NOINLINE st20 #-}
   !st20 :: T_Patterns_s20
st20 = let
      k20 :: K_Patterns_s20  t -> t
      k20 :: forall t. K_Patterns_s20 t -> t
k20 K_Patterns_s20 t
K_Patterns_v10 = T_Patterns_v10
v10
      k20 K_Patterns_s20 t
K_Patterns_v26 = T_Patterns_v26
v26
      k20 K_Patterns_s20 t
K_Patterns_v38 = T_Patterns_v38
v38
      k20 K_Patterns_s20 t
K_Patterns_v45 = T_Patterns_v45
v45
      k20 K_Patterns_s20 t
K_Patterns_v51 = T_Patterns_v51
v51
      k20 K_Patterns_s20 t
K_Patterns_v57 = T_Patterns_v57
v57
      v10 :: T_Patterns_v10 
      v10 :: T_Patterns_v10
v10 = \ !(T_Patterns_vIn10 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule217  () in
         let !_copy :: [a]
_copy = forall {a}. () -> [a]
rule220  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule218  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule219  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule221  () in
         let _lhsOcopy :: Patterns
             !_lhsOcopy :: Patterns
_lhsOcopy = forall a. a -> a
rule222 forall a. [a]
_copy in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule223 forall a. [a]
_output in
         let !__result_ :: T_Patterns_vOut10
__result_ = AttrMap
-> Patterns
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> T_Patterns_vOut10
T_Patterns_vOut10 AttrMap
_lhsOallAttributes Patterns
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut10
__result_ )
      v26 :: T_Patterns_v26 
      v26 :: T_Patterns_v26
v26 = \ !(T_Patterns_vIn26 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule217  () in
         let !_copy :: [a]
_copy = forall {a}. () -> [a]
rule220  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule218  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule219  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule221  () in
         let _lhsOcopy :: Patterns
             !_lhsOcopy :: Patterns
_lhsOcopy = forall a. a -> a
rule222 forall a. [a]
_copy in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule223 forall a. [a]
_output in
         let !__result_ :: T_Patterns_vOut26
__result_ = AttrMap
-> Patterns
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> T_Patterns_vOut26
T_Patterns_vOut26 AttrMap
_lhsOallAttributes Patterns
_lhsOcopy Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut26
__result_ )
      v38 :: T_Patterns_v38 
      v38 :: T_Patterns_v38
v38 = \ !(T_Patterns_vIn38 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule217  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule218  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule219  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule221  () in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule223 forall a. [a]
_output in
         let !__result_ :: T_Patterns_vOut38
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Patterns
-> T_Patterns_vOut38
T_Patterns_vOut38 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut38
__result_ )
      v45 :: T_Patterns_v45 
      v45 :: T_Patterns_v45
v45 = \ !(T_Patterns_vIn45 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule217  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule218  () in
         let !__st_ :: T_Patterns_s53
__st_ = () -> T_Patterns_s53
st53  ()
             !__result_ :: T_Patterns_vOut45
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Patterns_s53
-> T_Patterns_vOut45
T_Patterns_vOut45 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Patterns_s53
__st_
          in T_Patterns_vOut45
__result_ )
      v51 :: T_Patterns_v51 
      v51 :: T_Patterns_v51
v51 = \ !(T_Patterns_vIn51
T_Patterns_vIn51 ) -> (
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule218  () in
         let !__st_ :: T_Patterns_s56
__st_ = () -> T_Patterns_s56
st56  ()
             !__result_ :: T_Patterns_vOut51
__result_ = Set (NontermIdent, NontermIdent)
-> T_Patterns_s56 -> T_Patterns_vOut51
T_Patterns_vOut51 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Patterns_s56
__st_
          in T_Patterns_vOut51
__result_ )
      v57 :: T_Patterns_v57 
      v57 :: T_Patterns_v57
v57 = \ !(T_Patterns_vIn57 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule217  () in
         let !__st_ :: T_Patterns_s59
__st_ = () -> T_Patterns_s59
st59  ()
             !__result_ :: T_Patterns_vOut57
__result_ = AttrMap -> T_Patterns_s59 -> T_Patterns_vOut57
T_Patterns_vOut57 AttrMap
_lhsOallAttributes T_Patterns_s59
__st_
          in T_Patterns_vOut57
__result_ )
     in (forall t. K_Patterns_s20 t -> t) -> T_Patterns_s20
C_Patterns_s20 forall t. K_Patterns_s20 t -> t
k20
   {-# NOINLINE st53 #-}
   st53 :: () -> T_Patterns_s53
st53 = \  (()
_ :: ()) -> let
      v47 :: T_Patterns_v47 
      v47 :: T_Patterns_v47
v47 = \ !(T_Patterns_vIn47 [(NontermIdent, NontermIdent)]
_lhsIchildInhs Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule219  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule221  () in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule223 forall a. [a]
_output in
         let !__result_ :: T_Patterns_vOut47
__result_ = Seq Error -> Patterns -> T_Patterns_vOut47
T_Patterns_vOut47 Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut47
__result_ )
     in T_Patterns_v47 -> T_Patterns_s53
C_Patterns_s53 T_Patterns_v47
v47
   {-# NOINLINE st56 #-}
   st56 :: () -> T_Patterns_s56
st56 = \  (()
_ :: ()) -> let
      v52 :: T_Patterns_v52 
      v52 :: T_Patterns_v52
v52 = \ !(T_Patterns_vIn52 [(NontermIdent, NontermIdent)]
_lhsIchildInhs NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule217  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule219  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule221  () in
         let _lhsOoutput :: Patterns
             !_lhsOoutput :: Patterns
_lhsOoutput = forall a. a -> a
rule223 forall a. [a]
_output in
         let !__result_ :: T_Patterns_vOut52
__result_ = AttrMap -> Seq Error -> Patterns -> T_Patterns_vOut52
T_Patterns_vOut52 AttrMap
_lhsOallAttributes Seq Error
_lhsOerrors Patterns
_lhsOoutput
          in T_Patterns_vOut52
__result_ )
     in T_Patterns_v52 -> T_Patterns_s56
C_Patterns_s56 T_Patterns_v52
v52
   {-# NOINLINE st59 #-}
   st59 :: () -> T_Patterns_s59
st59 = \  (()
_ :: ()) -> let
      v58 :: T_Patterns_v58 
      v58 :: T_Patterns_v58
v58 = \ !(T_Patterns_vIn58
T_Patterns_vIn58 ) -> (
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule218  () in
         let !__st_ :: T_Patterns_s53
__st_ = () -> T_Patterns_s53
st53  ()
             !__result_ :: T_Patterns_vOut58
__result_ = Set (NontermIdent, NontermIdent)
-> T_Patterns_s53 -> T_Patterns_vOut58
T_Patterns_vOut58 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Patterns_s53
__st_
          in T_Patterns_vOut58
__result_ )
     in T_Patterns_v58 -> T_Patterns_s59
C_Patterns_s59 T_Patterns_v58
v58
   {-# NOINLINE[1] rule217 #-}
   rule217 :: () -> Map k a
rule217 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule218 #-}
   rule218 :: () -> Set a
rule218 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# NOINLINE[1] rule219 #-}
   rule219 :: () -> Seq a
rule219 = \  (()
_ :: ()) ->
     forall a. Seq a
Seq.empty
   {-# NOINLINE[1] rule220 #-}
   rule220 :: () -> [a]
rule220 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule221 #-}
   rule221 :: () -> [a]
rule221 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule222 #-}
   rule222 :: p -> p
rule222 = \ !p
_copy ->
     p
_copy
   {-# NOINLINE[1] rule223 #-}
   rule223 :: p -> p
rule223 = \ !p
_output ->
     p
_output

-- Production --------------------------------------------------
-- wrapper
data Inh_Production  = Inh_Production { Inh_Production -> Map NontermIdent (Map NontermIdent [Expression])
augmentsIn_Inh_Production :: !(Map ConstructorIdent (Map Identifier [Expression])), Inh_Production -> AttrMap
forcedIrrefutables_Inh_Production :: !(AttrMap), Inh_Production -> Map NontermIdent Attributes
inhMap_Inh_Production :: !(Map Identifier Attributes), Inh_Production -> String
mainName_Inh_Production :: !(String), Inh_Production -> NontermIdent
nt_Inh_Production :: !(NontermIdent), Inh_Production -> Options
options_Inh_Production :: !(Options), Inh_Production -> Map NontermIdent Attributes
synMap_Inh_Production :: !(Map Identifier Attributes) }
data Syn_Production  = Syn_Production { Syn_Production -> AttrMap
allAttributes_Syn_Production :: !(AttrMap), Syn_Production -> Map NontermIdent (Map NontermIdent [Expression])
augmentsOut_Syn_Production :: !(Map ConstructorIdent (Map Identifier [Expression])), Syn_Production -> Seq Error
errors_Syn_Production :: !(Seq Error), Syn_Production -> Production
output_Syn_Production :: !(Production) }
{-# INLINABLE wrap_Production #-}
wrap_Production :: T_Production  -> Inh_Production  -> (Syn_Production )
wrap_Production :: T_Production -> Inh_Production -> Syn_Production
wrap_Production !(T_Production Identity T_Production_s22
act) !(Inh_Production Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Production_s22
sem <- Identity T_Production_s22
act
        let arg11 :: T_Production_vIn11
arg11 = Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Production_vIn11
T_Production_vIn11 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap
        !(T_Production_vOut11 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Production
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Production_s22 -> forall t. K_Production_s22 t -> t
inv_Production_s22 T_Production_s22
sem K_Production_s22 T_Production_v11
K_Production_v11 T_Production_vIn11
arg11)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Production
-> Syn_Production
Syn_Production AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Production
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Production  = T_Production {
                                     T_Production -> Identity T_Production_s22
attach_T_Production :: Identity (T_Production_s22 )
                                     }
data T_Production_s22  where C_Production_s22 :: {
                                                 T_Production_s22 -> forall t. K_Production_s22 t -> t
inv_Production_s22 :: !(forall t. K_Production_s22  t -> t)
                                                 } -> T_Production_s22 
data T_Production_s23  = C_Production_s23
data T_Production_s44  = C_Production_s44
newtype T_Production_s52  = C_Production_s52 {
                                             T_Production_s52 -> T_Production_v44
inv_Production_s52 :: (T_Production_v44 )
                                             }
data K_Production_s22 k  where
   K_Production_v11 :: K_Production_s22  (T_Production_v11 )
   K_Production_v30 :: K_Production_s22  (T_Production_v30 )
   K_Production_v43 :: K_Production_s22  (T_Production_v43 )
type T_Production_v11  = (T_Production_vIn11 ) -> (T_Production_vOut11 )
data T_Production_vIn11  = T_Production_vIn11 !(Map ConstructorIdent (Map Identifier [Expression])) !(AttrMap) !(Map Identifier Attributes) !(String) !(NontermIdent) !(Options) !(Map Identifier Attributes)
data T_Production_vOut11  = T_Production_vOut11 !(AttrMap) !(Map ConstructorIdent (Map Identifier [Expression])) !(Seq Error) !(Production)
type T_Production_v30  = (T_Production_vIn30 ) -> (T_Production_vOut30 )
data T_Production_vIn30  = T_Production_vIn30 !(Map ConstructorIdent (Map Identifier [Expression])) !(AttrMap) !(Map Identifier Attributes) !(NontermIdent) !(Options) !(Map Identifier Attributes)
data T_Production_vOut30  = T_Production_vOut30 !(AttrMap) !(Map ConstructorIdent (Map Identifier [Expression])) !(Seq Error) !(Production)
type T_Production_v43  = (T_Production_vIn43 ) -> (T_Production_vOut43 )
data T_Production_vIn43  = T_Production_vIn43 !(NontermIdent)
data T_Production_vOut43  = T_Production_vOut43 !(AttrMap) !(T_Production_s52 )
type T_Production_v44  = (T_Production_vIn44 ) -> (T_Production_vOut44 )
data T_Production_vIn44  = T_Production_vIn44 !(Map ConstructorIdent (Map Identifier [Expression])) !(AttrMap) !(Map Identifier Attributes) !(Options) !(Map Identifier Attributes)
data T_Production_vOut44  = T_Production_vOut44 !(Map ConstructorIdent (Map Identifier [Expression])) !(Seq Error) !(Production)
{-# NOINLINE sem_Production_Production #-}
sem_Production_Production :: (ConstructorIdent) -> ([Identifier]) -> ([Type]) -> T_Children  -> T_Rules  -> T_TypeSigs  -> (MaybeMacro) -> T_Production 
sem_Production_Production :: NontermIdent
-> [NontermIdent]
-> [Type]
-> T_Children
-> T_Rules
-> T_TypeSigs
-> MaybeMacro
-> T_Production
sem_Production_Production !NontermIdent
arg_con_ ![NontermIdent]
arg_params_ ![Type]
arg_constraints_ T_Children
arg_children_ T_Rules
arg_rules_ T_TypeSigs
arg_typeSigs_ !MaybeMacro
arg_macro_ = Identity T_Production_s22 -> T_Production
T_Production (forall (m :: * -> *) a. Monad m => a -> m a
return T_Production_s22
st22) where
   {-# NOINLINE st22 #-}
   !st22 :: T_Production_s22
st22 = let
      k22 :: K_Production_s22  t -> t
      k22 :: forall t. K_Production_s22 t -> t
k22 K_Production_s22 t
K_Production_v11 = T_Production_v11
v11
      k22 K_Production_s22 t
K_Production_v30 = T_Production_vIn30 -> T_Production_vOut30
v30
      k22 K_Production_s22 t
K_Production_v43 = T_Production_vIn43 -> T_Production_vOut43
v43
      v11 :: T_Production_v11 
      v11 :: T_Production_v11
v11 = \ !(T_Production_vIn11 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_rulesX28 :: T_Rules_s28
_rulesX28 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s28
attach_T_Rules (T_Rules
arg_rules_)) in
         let !_childrenX2 :: T_Children_s2
_childrenX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s2
attach_T_Children (T_Children
arg_children_)) in
         let !_typeSigsX32 :: T_TypeSigs_s32
_typeSigsX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s32
attach_T_TypeSigs (T_TypeSigs
arg_typeSigs_)) in
         let !_rulesOcon :: NontermIdent
_rulesOcon = forall a. a -> a
rule224 NontermIdent
arg_con_ in
         let !_rulesOnt :: NontermIdent
_rulesOnt = NontermIdent -> NontermIdent
rule241 NontermIdent
_lhsInt in
         let !_childrenOinhMap :: Map NontermIdent Attributes
_childrenOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule234 Map NontermIdent Attributes
_lhsIinhMap in
         let !_childrenOsynMap :: Map NontermIdent Attributes
_childrenOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule237 Map NontermIdent Attributes
_lhsIsynMap in
         let !_augmentsIn :: Map NontermIdent [Expression]
_augmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> NontermIdent -> Map NontermIdent [Expression]
rule226 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn NontermIdent
arg_con_ in
         let !_rulesOoptions :: Options
_rulesOoptions = Options -> Options
rule242 Options
_lhsIoptions in
         let !_rulesOforcedIrrefutables :: AttrMap
_rulesOforcedIrrefutables = AttrMap -> AttrMap
rule240 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Children_vOut18 [(NontermIdent, NontermIdent)]
_childrenIchildInhs [(NontermIdent, NontermIdent)]
_childrenIchildSyns Children
_childrenIoutput) = T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 T_Children_s2
_childrenX2 K_Children_s2 (T_Children_vIn18 -> T_Children_vOut18)
K_Children_v18 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Children_vIn18
T_Children_vIn18 Map NontermIdent Attributes
_childrenOinhMap Map NontermIdent Attributes
_childrenOsynMap) in
         let !(T_Rules_vOut28 AttrMap
_rulesIallAttributes Set (NontermIdent, NontermIdent)
_rulesIdefsCollect T_Rules_s43
_rulesX43) = T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
_rulesX28 K_Rules_s28 T_Rules_v28
K_Rules_v28 (NontermIdent -> NontermIdent -> T_Rules_vIn28
T_Rules_vIn28 NontermIdent
_rulesOcon NontermIdent
_rulesOnt) in
         let !(T_TypeSigs_vOut16 TypeSigs
_typeSigsIoutput) = T_TypeSigs_s32 -> T_TypeSigs_v16
inv_TypeSigs_s32 T_TypeSigs_s32
_typeSigsX32 (T_TypeSigs_vIn16
T_TypeSigs_vIn16 ) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule230 AttrMap
_rulesIallAttributes in
         let !(!Seq Error
_augmentErrs,!Map NontermIdent [Expression]
_augmentsOut1) = forall {k}.
Map k [Expression]
-> [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Options
-> NontermIdent
-> (Seq Error, Map k [Expression])
rule228 Map NontermIdent [Expression]
_augmentsIn [(NontermIdent, NontermIdent)]
_childrenIchildInhs [(NontermIdent, NontermIdent)]
_childrenIchildSyns NontermIdent
_lhsInt Options
_lhsIoptions NontermIdent
arg_con_ in
         let !_augmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_augmentsOut = forall {a} {k}. a -> k -> Map k a
rule227 Map NontermIdent [Expression]
_augmentsOut1 NontermIdent
arg_con_ in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = forall a. a -> a
rule231 Map NontermIdent (Map NontermIdent [Expression])
_augmentsOut in
         let !_rulesOchildInhs :: [(NontermIdent, NontermIdent)]
_rulesOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule238 [(NontermIdent, NontermIdent)]
_childrenIchildInhs in
         let !_rulesOchildSyns :: [(NontermIdent, NontermIdent)]
_rulesOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule239 [(NontermIdent, NontermIdent)]
_childrenIchildSyns in
         let !_rulesOdefs :: Set (NontermIdent, NontermIdent)
_rulesOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule225 Set (NontermIdent, NontermIdent)
_rulesIdefsCollect in
         let !(T_Rules_vOut29 Seq Error
_rulesIerrors Rules
_rulesIoutput) = T_Rules_s43 -> T_Rules_v29
inv_Rules_s43 T_Rules_s43
_rulesX43 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> Options
-> T_Rules_vIn29
T_Rules_vIn29 [(NontermIdent, NontermIdent)]
_rulesOchildInhs [(NontermIdent, NontermIdent)]
_rulesOchildSyns Set (NontermIdent, NontermIdent)
_rulesOdefs AttrMap
_rulesOforcedIrrefutables Options
_rulesOoptions) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule229 Seq Error
_augmentErrs Seq Error
_rulesIerrors in
         let !_output :: Production
_output = Children
-> Rules
-> TypeSigs
-> NontermIdent
-> [Type]
-> MaybeMacro
-> [NontermIdent]
-> Production
rule232 Children
_childrenIoutput Rules
_rulesIoutput TypeSigs
_typeSigsIoutput NontermIdent
arg_con_ [Type]
arg_constraints_ MaybeMacro
arg_macro_ [NontermIdent]
arg_params_ in
         let _lhsOoutput :: Production
             !_lhsOoutput :: Production
_lhsOoutput = forall a. a -> a
rule233 Production
_output in
         let !__result_ :: T_Production_vOut11
__result_ = AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Production
-> T_Production_vOut11
T_Production_vOut11 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Production
_lhsOoutput
          in T_Production_vOut11
__result_ )
      v30 :: T_Production_v30 
      v30 :: T_Production_vIn30 -> T_Production_vOut30
v30 = \ !(T_Production_vIn30 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_rulesX28 :: T_Rules_s28
_rulesX28 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s28
attach_T_Rules (T_Rules
arg_rules_)) in
         let !_childrenX2 :: T_Children_s2
_childrenX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s2
attach_T_Children (T_Children
arg_children_)) in
         let !_typeSigsX32 :: T_TypeSigs_s32
_typeSigsX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s32
attach_T_TypeSigs (T_TypeSigs
arg_typeSigs_)) in
         let !_rulesOcon :: NontermIdent
_rulesOcon = forall a. a -> a
rule224 NontermIdent
arg_con_ in
         let !_rulesOnt :: NontermIdent
_rulesOnt = NontermIdent -> NontermIdent
rule241 NontermIdent
_lhsInt in
         let !_childrenOinhMap :: Map NontermIdent Attributes
_childrenOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule234 Map NontermIdent Attributes
_lhsIinhMap in
         let !_childrenOsynMap :: Map NontermIdent Attributes
_childrenOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule237 Map NontermIdent Attributes
_lhsIsynMap in
         let !_augmentsIn :: Map NontermIdent [Expression]
_augmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> NontermIdent -> Map NontermIdent [Expression]
rule226 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn NontermIdent
arg_con_ in
         let !_rulesOoptions :: Options
_rulesOoptions = Options -> Options
rule242 Options
_lhsIoptions in
         let !_rulesOforcedIrrefutables :: AttrMap
_rulesOforcedIrrefutables = AttrMap -> AttrMap
rule240 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Children_vOut18 [(NontermIdent, NontermIdent)]
_childrenIchildInhs [(NontermIdent, NontermIdent)]
_childrenIchildSyns Children
_childrenIoutput) = T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 T_Children_s2
_childrenX2 K_Children_s2 (T_Children_vIn18 -> T_Children_vOut18)
K_Children_v18 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Children_vIn18
T_Children_vIn18 Map NontermIdent Attributes
_childrenOinhMap Map NontermIdent Attributes
_childrenOsynMap) in
         let !(T_Rules_vOut28 AttrMap
_rulesIallAttributes Set (NontermIdent, NontermIdent)
_rulesIdefsCollect T_Rules_s43
_rulesX43) = T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
_rulesX28 K_Rules_s28 T_Rules_v28
K_Rules_v28 (NontermIdent -> NontermIdent -> T_Rules_vIn28
T_Rules_vIn28 NontermIdent
_rulesOcon NontermIdent
_rulesOnt) in
         let !(T_TypeSigs_vOut16 TypeSigs
_typeSigsIoutput) = T_TypeSigs_s32 -> T_TypeSigs_v16
inv_TypeSigs_s32 T_TypeSigs_s32
_typeSigsX32 (T_TypeSigs_vIn16
T_TypeSigs_vIn16 ) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule230 AttrMap
_rulesIallAttributes in
         let !(!Seq Error
_augmentErrs,!Map NontermIdent [Expression]
_augmentsOut1) = forall {k}.
Map k [Expression]
-> [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Options
-> NontermIdent
-> (Seq Error, Map k [Expression])
rule228 Map NontermIdent [Expression]
_augmentsIn [(NontermIdent, NontermIdent)]
_childrenIchildInhs [(NontermIdent, NontermIdent)]
_childrenIchildSyns NontermIdent
_lhsInt Options
_lhsIoptions NontermIdent
arg_con_ in
         let !_augmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_augmentsOut = forall {a} {k}. a -> k -> Map k a
rule227 Map NontermIdent [Expression]
_augmentsOut1 NontermIdent
arg_con_ in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = forall a. a -> a
rule231 Map NontermIdent (Map NontermIdent [Expression])
_augmentsOut in
         let !_rulesOchildInhs :: [(NontermIdent, NontermIdent)]
_rulesOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule238 [(NontermIdent, NontermIdent)]
_childrenIchildInhs in
         let !_rulesOchildSyns :: [(NontermIdent, NontermIdent)]
_rulesOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule239 [(NontermIdent, NontermIdent)]
_childrenIchildSyns in
         let !_rulesOdefs :: Set (NontermIdent, NontermIdent)
_rulesOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule225 Set (NontermIdent, NontermIdent)
_rulesIdefsCollect in
         let !(T_Rules_vOut29 Seq Error
_rulesIerrors Rules
_rulesIoutput) = T_Rules_s43 -> T_Rules_v29
inv_Rules_s43 T_Rules_s43
_rulesX43 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> Options
-> T_Rules_vIn29
T_Rules_vIn29 [(NontermIdent, NontermIdent)]
_rulesOchildInhs [(NontermIdent, NontermIdent)]
_rulesOchildSyns Set (NontermIdent, NontermIdent)
_rulesOdefs AttrMap
_rulesOforcedIrrefutables Options
_rulesOoptions) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule229 Seq Error
_augmentErrs Seq Error
_rulesIerrors in
         let !_output :: Production
_output = Children
-> Rules
-> TypeSigs
-> NontermIdent
-> [Type]
-> MaybeMacro
-> [NontermIdent]
-> Production
rule232 Children
_childrenIoutput Rules
_rulesIoutput TypeSigs
_typeSigsIoutput NontermIdent
arg_con_ [Type]
arg_constraints_ MaybeMacro
arg_macro_ [NontermIdent]
arg_params_ in
         let _lhsOoutput :: Production
             !_lhsOoutput :: Production
_lhsOoutput = forall a. a -> a
rule233 Production
_output in
         let !__result_ :: T_Production_vOut30
__result_ = AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Production
-> T_Production_vOut30
T_Production_vOut30 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Production
_lhsOoutput
          in T_Production_vOut30
__result_ )
      v43 :: T_Production_v43 
      v43 :: T_Production_vIn43 -> T_Production_vOut43
v43 = \ !(T_Production_vIn43 NontermIdent
_lhsInt) -> (
         let !_rulesX28 :: T_Rules_s28
_rulesX28 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s28
attach_T_Rules (T_Rules
arg_rules_)) in
         let !_rulesOcon :: NontermIdent
_rulesOcon = forall a. a -> a
rule224 NontermIdent
arg_con_ in
         let !_rulesOnt :: NontermIdent
_rulesOnt = NontermIdent -> NontermIdent
rule241 NontermIdent
_lhsInt in
         let !(T_Rules_vOut49 AttrMap
_rulesIallAttributes T_Rules_s55
_rulesX55) = T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
_rulesX28 K_Rules_s28 T_Rules_v49
K_Rules_v49 (NontermIdent -> NontermIdent -> T_Rules_vIn49
T_Rules_vIn49 NontermIdent
_rulesOcon NontermIdent
_rulesOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule230 AttrMap
_rulesIallAttributes in
         let !__st_ :: T_Production_s52
__st_ = NontermIdent -> T_Rules_s55 -> T_Production_s52
st52 NontermIdent
_lhsInt T_Rules_s55
_rulesX55
             !__result_ :: T_Production_vOut43
__result_ = AttrMap -> T_Production_s52 -> T_Production_vOut43
T_Production_vOut43 AttrMap
_lhsOallAttributes T_Production_s52
__st_
          in T_Production_vOut43
__result_ )
     in (forall t. K_Production_s22 t -> t) -> T_Production_s22
C_Production_s22 forall t. K_Production_s22 t -> t
k22
   {-# NOINLINE st52 #-}
   st52 :: NontermIdent -> T_Rules_s55 -> T_Production_s52
st52 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) !T_Rules_s55
_rulesX55 -> let
      v44 :: T_Production_v44 
      v44 :: T_Production_v44
v44 = \ !(T_Production_vIn44 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_childrenX2 :: T_Children_s2
_childrenX2 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Children -> Identity T_Children_s2
attach_T_Children (T_Children
arg_children_)) in
         let !_typeSigsX32 :: T_TypeSigs_s32
_typeSigsX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s32
attach_T_TypeSigs (T_TypeSigs
arg_typeSigs_)) in
         let !_childrenOinhMap :: Map NontermIdent Attributes
_childrenOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule234 Map NontermIdent Attributes
_lhsIinhMap in
         let !_childrenOsynMap :: Map NontermIdent Attributes
_childrenOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule237 Map NontermIdent Attributes
_lhsIsynMap in
         let !_augmentsIn :: Map NontermIdent [Expression]
_augmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> NontermIdent -> Map NontermIdent [Expression]
rule226 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn NontermIdent
arg_con_ in
         let !_rulesOoptions :: Options
_rulesOoptions = Options -> Options
rule242 Options
_lhsIoptions in
         let !_rulesOforcedIrrefutables :: AttrMap
_rulesOforcedIrrefutables = AttrMap -> AttrMap
rule240 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Children_vOut18 [(NontermIdent, NontermIdent)]
_childrenIchildInhs [(NontermIdent, NontermIdent)]
_childrenIchildSyns Children
_childrenIoutput) = T_Children_s2 -> forall t. K_Children_s2 t -> t
inv_Children_s2 T_Children_s2
_childrenX2 K_Children_s2 (T_Children_vIn18 -> T_Children_vOut18)
K_Children_v18 (Map NontermIdent Attributes
-> Map NontermIdent Attributes -> T_Children_vIn18
T_Children_vIn18 Map NontermIdent Attributes
_childrenOinhMap Map NontermIdent Attributes
_childrenOsynMap) in
         let !(T_Rules_vOut50 Set (NontermIdent, NontermIdent)
_rulesIdefsCollect T_Rules_s43
_rulesX43) = T_Rules_s55 -> T_Rules_v50
inv_Rules_s55 T_Rules_s55
_rulesX55 (T_Rules_vIn50
T_Rules_vIn50 ) in
         let !(T_TypeSigs_vOut16 TypeSigs
_typeSigsIoutput) = T_TypeSigs_s32 -> T_TypeSigs_v16
inv_TypeSigs_s32 T_TypeSigs_s32
_typeSigsX32 (T_TypeSigs_vIn16
T_TypeSigs_vIn16 ) in
         let !(!Seq Error
_augmentErrs,!Map NontermIdent [Expression]
_augmentsOut1) = forall {k}.
Map k [Expression]
-> [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Options
-> NontermIdent
-> (Seq Error, Map k [Expression])
rule228 Map NontermIdent [Expression]
_augmentsIn [(NontermIdent, NontermIdent)]
_childrenIchildInhs [(NontermIdent, NontermIdent)]
_childrenIchildSyns NontermIdent
_lhsInt Options
_lhsIoptions NontermIdent
arg_con_ in
         let !_augmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_augmentsOut = forall {a} {k}. a -> k -> Map k a
rule227 Map NontermIdent [Expression]
_augmentsOut1 NontermIdent
arg_con_ in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = forall a. a -> a
rule231 Map NontermIdent (Map NontermIdent [Expression])
_augmentsOut in
         let !_rulesOchildInhs :: [(NontermIdent, NontermIdent)]
_rulesOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule238 [(NontermIdent, NontermIdent)]
_childrenIchildInhs in
         let !_rulesOchildSyns :: [(NontermIdent, NontermIdent)]
_rulesOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule239 [(NontermIdent, NontermIdent)]
_childrenIchildSyns in
         let !_rulesOdefs :: Set (NontermIdent, NontermIdent)
_rulesOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule225 Set (NontermIdent, NontermIdent)
_rulesIdefsCollect in
         let !(T_Rules_vOut29 Seq Error
_rulesIerrors Rules
_rulesIoutput) = T_Rules_s43 -> T_Rules_v29
inv_Rules_s43 T_Rules_s43
_rulesX43 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> Options
-> T_Rules_vIn29
T_Rules_vIn29 [(NontermIdent, NontermIdent)]
_rulesOchildInhs [(NontermIdent, NontermIdent)]
_rulesOchildSyns Set (NontermIdent, NontermIdent)
_rulesOdefs AttrMap
_rulesOforcedIrrefutables Options
_rulesOoptions) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule229 Seq Error
_augmentErrs Seq Error
_rulesIerrors in
         let !_output :: Production
_output = Children
-> Rules
-> TypeSigs
-> NontermIdent
-> [Type]
-> MaybeMacro
-> [NontermIdent]
-> Production
rule232 Children
_childrenIoutput Rules
_rulesIoutput TypeSigs
_typeSigsIoutput NontermIdent
arg_con_ [Type]
arg_constraints_ MaybeMacro
arg_macro_ [NontermIdent]
arg_params_ in
         let _lhsOoutput :: Production
             !_lhsOoutput :: Production
_lhsOoutput = forall a. a -> a
rule233 Production
_output in
         let !__result_ :: T_Production_vOut44
__result_ = Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error -> Production -> T_Production_vOut44
T_Production_vOut44 Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Production
_lhsOoutput
          in T_Production_vOut44
__result_ )
     in T_Production_v44 -> T_Production_s52
C_Production_s52 T_Production_v44
v44
   {-# NOINLINE[1] rule224 #-}
   {-# LINE 161 "src-ag/Desugar.ag" #-}
   rule224 = \ !con_ ->
                    {-# LINE 161 "src-ag/Desugar.ag" #-}
                    con_
                    {-# LINE 3504 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule225 #-}
   {-# LINE 188 "src-ag/Desugar.ag" #-}
   rule225 = \ ((!_rulesIdefsCollect) :: Set (Identifier, Identifier)) ->
                     {-# LINE 188 "src-ag/Desugar.ag" #-}
                     _rulesIdefsCollect
                     {-# LINE 3510 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule226 #-}
   {-# LINE 244 "src-ag/Desugar.ag" #-}
   rule226 = \ ((!_lhsIaugmentsIn) :: Map ConstructorIdent (Map Identifier [Expression])) !con_ ->
                         {-# LINE 244 "src-ag/Desugar.ag" #-}
                         Map.findWithDefault Map.empty con_ _lhsIaugmentsIn
                         {-# LINE 3516 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule227 #-}
   {-# LINE 245 "src-ag/Desugar.ag" #-}
   rule227 = \ !_augmentsOut1 !con_ ->
                          {-# LINE 245 "src-ag/Desugar.ag" #-}
                          Map.singleton con_ _augmentsOut1
                          {-# LINE 3522 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule228 #-}
   {-# LINE 247 "src-ag/Desugar.ag" #-}
   rule228 = \ !_augmentsIn ((!_childrenIchildInhs) :: [(Identifier, Identifier)]) ((!_childrenIchildSyns) :: [(Identifier, Identifier)]) ((!_lhsInt) :: NontermIdent) ((!_lhsIoptions) :: Options) !con_ ->
                                              {-# LINE 247 "src-ag/Desugar.ag" #-}
                                              Map.mapAccum (desugarExprs _lhsIoptions _lhsInt con_ _childrenIchildInhs _childrenIchildSyns) Seq.empty _augmentsIn
                                              {-# LINE 3528 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule229 #-}
   {-# LINE 283 "src-ag/Desugar.ag" #-}
   rule229 = \ !_augmentErrs ((!_rulesIerrors) :: Seq Error) ->
                     {-# LINE 283 "src-ag/Desugar.ag" #-}
                     _rulesIerrors Seq.>< _augmentErrs
                     {-# LINE 3534 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule230 #-}
   rule230 = \ ((!_rulesIallAttributes) :: AttrMap) ->
     _rulesIallAttributes
   {-# NOINLINE[1] rule231 #-}
   rule231 = \ !_augmentsOut ->
     _augmentsOut
   {-# NOINLINE[1] rule232 #-}
   rule232 = \ ((!_childrenIoutput) :: Children) ((!_rulesIoutput) :: Rules) ((!_typeSigsIoutput) :: TypeSigs) !con_ !constraints_ !macro_ !params_ ->
     Production con_ params_ constraints_ _childrenIoutput _rulesIoutput _typeSigsIoutput macro_
   {-# NOINLINE[1] rule233 #-}
   rule233 = \ !_output ->
     _output
   {-# NOINLINE[1] rule234 #-}
   rule234 = \ ((!_lhsIinhMap) :: Map Identifier Attributes) ->
     _lhsIinhMap
   {-# NOINLINE[1] rule237 #-}
   rule237 = \ ((!_lhsIsynMap) :: Map Identifier Attributes) ->
     _lhsIsynMap
   {-# NOINLINE[1] rule238 #-}
   rule238 = \ ((!_childrenIchildInhs) :: [(Identifier, Identifier)]) ->
     _childrenIchildInhs
   {-# NOINLINE[1] rule239 #-}
   rule239 = \ ((!_childrenIchildSyns) :: [(Identifier, Identifier)]) ->
     _childrenIchildSyns
   {-# NOINLINE[1] rule240 #-}
   rule240 = \ ((!_lhsIforcedIrrefutables) :: AttrMap) ->
     _lhsIforcedIrrefutables
   {-# NOINLINE[1] rule241 #-}
   rule241 = \ ((!_lhsInt) :: NontermIdent) ->
     _lhsInt
   {-# NOINLINE[1] rule242 #-}
   rule242 = \ ((!_lhsIoptions) :: Options) ->
     _lhsIoptions

-- Productions -------------------------------------------------
-- wrapper
data Inh_Productions  = Inh_Productions { Inh_Productions -> Map NontermIdent (Map NontermIdent [Expression])
augmentsIn_Inh_Productions :: !(Map ConstructorIdent (Map Identifier [Expression])), Inh_Productions -> AttrMap
forcedIrrefutables_Inh_Productions :: !(AttrMap), Inh_Productions -> Map NontermIdent Attributes
inhMap_Inh_Productions :: !(Map Identifier Attributes), Inh_Productions -> String
mainName_Inh_Productions :: !(String), Inh_Productions -> NontermIdent
nt_Inh_Productions :: !(NontermIdent), Inh_Productions -> Options
options_Inh_Productions :: !(Options), Inh_Productions -> Map NontermIdent Attributes
synMap_Inh_Productions :: !(Map Identifier Attributes) }
data Syn_Productions  = Syn_Productions { Syn_Productions -> AttrMap
allAttributes_Syn_Productions :: !(AttrMap), Syn_Productions -> Map NontermIdent (Map NontermIdent [Expression])
augmentsOut_Syn_Productions :: !(Map ConstructorIdent (Map Identifier [Expression])), Syn_Productions -> Seq Error
errors_Syn_Productions :: !(Seq Error), Syn_Productions -> Productions
output_Syn_Productions :: !(Productions) }
{-# INLINABLE wrap_Productions #-}
wrap_Productions :: T_Productions  -> Inh_Productions  -> (Syn_Productions )
wrap_Productions :: T_Productions -> Inh_Productions -> Syn_Productions
wrap_Productions !(T_Productions Identity T_Productions_s24
act) !(Inh_Productions Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Productions_s24
sem <- Identity T_Productions_s24
act
        let arg12 :: T_Productions_vIn12
arg12 = Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> String
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Productions_vIn12
T_Productions_vIn12 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap
        !(T_Productions_vOut12 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 T_Productions_s24
sem K_Productions_s24 T_Productions_v12
K_Productions_v12 T_Productions_vIn12
arg12)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Productions
-> Syn_Productions
Syn_Productions AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Productions  = T_Productions {
                                       T_Productions -> Identity T_Productions_s24
attach_T_Productions :: Identity (T_Productions_s24 )
                                       }
data T_Productions_s24  where C_Productions_s24 :: {
                                                   T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 :: !(forall t. K_Productions_s24  t -> t)
                                                   } -> T_Productions_s24 
data T_Productions_s25  = C_Productions_s25
data T_Productions_s40  = C_Productions_s40
newtype T_Productions_s50  = C_Productions_s50 {
                                               T_Productions_s50 -> T_Productions_v40
inv_Productions_s50 :: (T_Productions_v40 )
                                               }
data K_Productions_s24 k  where
   K_Productions_v12 :: K_Productions_s24  (T_Productions_v12 )
   K_Productions_v25 :: K_Productions_s24  (T_Productions_v25 )
   K_Productions_v39 :: K_Productions_s24  (T_Productions_v39 )
type T_Productions_v12  = (T_Productions_vIn12 ) -> (T_Productions_vOut12 )
data T_Productions_vIn12  = T_Productions_vIn12 !(Map ConstructorIdent (Map Identifier [Expression])) !(AttrMap) !(Map Identifier Attributes) !(String) !(NontermIdent) !(Options) !(Map Identifier Attributes)
data T_Productions_vOut12  = T_Productions_vOut12 !(AttrMap) !(Map ConstructorIdent (Map Identifier [Expression])) !(Seq Error) !(Productions)
type T_Productions_v25  = (T_Productions_vIn25 ) -> (T_Productions_vOut25 )
data T_Productions_vIn25  = T_Productions_vIn25 !(Map ConstructorIdent (Map Identifier [Expression])) !(AttrMap) !(Map Identifier Attributes) !(NontermIdent) !(Options) !(Map Identifier Attributes)
data T_Productions_vOut25  = T_Productions_vOut25 !(AttrMap) !(Map ConstructorIdent (Map Identifier [Expression])) !(Seq Error) !(Productions)
type T_Productions_v39  = (T_Productions_vIn39 ) -> (T_Productions_vOut39 )
data T_Productions_vIn39  = T_Productions_vIn39 !(NontermIdent)
data T_Productions_vOut39  = T_Productions_vOut39 !(AttrMap) !(T_Productions_s50 )
type T_Productions_v40  = (T_Productions_vIn40 ) -> (T_Productions_vOut40 )
data T_Productions_vIn40  = T_Productions_vIn40 !(Map ConstructorIdent (Map Identifier [Expression])) !(AttrMap) !(Map Identifier Attributes) !(Options) !(Map Identifier Attributes)
data T_Productions_vOut40  = T_Productions_vOut40 !(Map ConstructorIdent (Map Identifier [Expression])) !(Seq Error) !(Productions)
{-# NOINLINE sem_Productions_Cons #-}
sem_Productions_Cons :: T_Production  -> T_Productions  -> T_Productions 
sem_Productions_Cons :: T_Production -> T_Productions -> T_Productions
sem_Productions_Cons T_Production
arg_hd_ T_Productions
arg_tl_ = Identity T_Productions_s24 -> T_Productions
T_Productions (forall (m :: * -> *) a. Monad m => a -> m a
return T_Productions_s24
st24) where
   {-# NOINLINE st24 #-}
   !st24 :: T_Productions_s24
st24 = let
      k24 :: K_Productions_s24  t -> t
      k24 :: forall t. K_Productions_s24 t -> t
k24 K_Productions_s24 t
K_Productions_v12 = T_Productions_v12
v12
      k24 K_Productions_s24 t
K_Productions_v25 = T_Productions_v25
v25
      k24 K_Productions_s24 t
K_Productions_v39 = T_Productions_v39
v39
      v12 :: T_Productions_v12 
      v12 :: T_Productions_v12
v12 = \ !(T_Productions_vIn12 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdX22 :: T_Production_s22
_hdX22 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Production -> Identity T_Production_s22
attach_T_Production (T_Production
arg_hd_)) in
         let !_tlX24 :: T_Productions_s24
_tlX24 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s24
attach_T_Productions (T_Productions
arg_tl_)) in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule252 NontermIdent
_lhsInt in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule259 NontermIdent
_lhsInt in
         let !_hdOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_hdOaugmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule248 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule250 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule253 Options
_lhsIoptions in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule254 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_tlOaugmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule255 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule257 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule260 Options
_lhsIoptions in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule261 Map NontermIdent Attributes
_lhsIsynMap in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule249 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule256 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Production_vOut30 AttrMap
_hdIallAttributes Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut Seq Error
_hdIerrors Production
_hdIoutput) = T_Production_s22 -> forall t. K_Production_s22 t -> t
inv_Production_s22 T_Production_s22
_hdX22 K_Production_s22 (T_Production_vIn30 -> T_Production_vOut30)
K_Production_v30 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Production_vIn30
T_Production_vIn30 Map NontermIdent (Map NontermIdent [Expression])
_hdOaugmentsIn AttrMap
_hdOforcedIrrefutables Map NontermIdent Attributes
_hdOinhMap NontermIdent
_hdOnt Options
_hdOoptions Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Productions_vOut25 AttrMap
_tlIallAttributes Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut Seq Error
_tlIerrors Productions
_tlIoutput) = T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 T_Productions_s24
_tlX24 K_Productions_s24 T_Productions_v25
K_Productions_v25 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Productions_vIn25
T_Productions_vIn25 Map NontermIdent (Map NontermIdent [Expression])
_tlOaugmentsIn AttrMap
_tlOforcedIrrefutables Map NontermIdent Attributes
_tlOinhMap NontermIdent
_tlOnt Options
_tlOoptions Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule243 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule244 Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule245 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Productions
_output = Production -> Productions -> Productions
rule246 Production
_hdIoutput Productions
_tlIoutput in
         let _lhsOoutput :: Productions
             !_lhsOoutput :: Productions
_lhsOoutput = forall a. a -> a
rule247 Productions
_output in
         let !__result_ :: T_Productions_vOut12
__result_ = AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Productions
-> T_Productions_vOut12
T_Productions_vOut12 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput
          in T_Productions_vOut12
__result_ )
      v25 :: T_Productions_v25 
      v25 :: T_Productions_v25
v25 = \ !(T_Productions_vIn25 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdX22 :: T_Production_s22
_hdX22 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Production -> Identity T_Production_s22
attach_T_Production (T_Production
arg_hd_)) in
         let !_tlX24 :: T_Productions_s24
_tlX24 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s24
attach_T_Productions (T_Productions
arg_tl_)) in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule252 NontermIdent
_lhsInt in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule259 NontermIdent
_lhsInt in
         let !_hdOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_hdOaugmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule248 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule250 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule253 Options
_lhsIoptions in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule254 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_tlOaugmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule255 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule257 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule260 Options
_lhsIoptions in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule261 Map NontermIdent Attributes
_lhsIsynMap in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule249 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule256 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Production_vOut30 AttrMap
_hdIallAttributes Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut Seq Error
_hdIerrors Production
_hdIoutput) = T_Production_s22 -> forall t. K_Production_s22 t -> t
inv_Production_s22 T_Production_s22
_hdX22 K_Production_s22 (T_Production_vIn30 -> T_Production_vOut30)
K_Production_v30 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Production_vIn30
T_Production_vIn30 Map NontermIdent (Map NontermIdent [Expression])
_hdOaugmentsIn AttrMap
_hdOforcedIrrefutables Map NontermIdent Attributes
_hdOinhMap NontermIdent
_hdOnt Options
_hdOoptions Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Productions_vOut25 AttrMap
_tlIallAttributes Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut Seq Error
_tlIerrors Productions
_tlIoutput) = T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 T_Productions_s24
_tlX24 K_Productions_s24 T_Productions_v25
K_Productions_v25 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> NontermIdent
-> Options
-> Map NontermIdent Attributes
-> T_Productions_vIn25
T_Productions_vIn25 Map NontermIdent (Map NontermIdent [Expression])
_tlOaugmentsIn AttrMap
_tlOforcedIrrefutables Map NontermIdent Attributes
_tlOinhMap NontermIdent
_tlOnt Options
_tlOoptions Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule243 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule244 Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule245 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Productions
_output = Production -> Productions -> Productions
rule246 Production
_hdIoutput Productions
_tlIoutput in
         let _lhsOoutput :: Productions
             !_lhsOoutput :: Productions
_lhsOoutput = forall a. a -> a
rule247 Productions
_output in
         let !__result_ :: T_Productions_vOut25
__result_ = AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Productions
-> T_Productions_vOut25
T_Productions_vOut25 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput
          in T_Productions_vOut25
__result_ )
      v39 :: T_Productions_v39 
      v39 :: T_Productions_v39
v39 = \ !(T_Productions_vIn39 NontermIdent
_lhsInt) -> (
         let !_hdX22 :: T_Production_s22
_hdX22 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Production -> Identity T_Production_s22
attach_T_Production (T_Production
arg_hd_)) in
         let !_tlX24 :: T_Productions_s24
_tlX24 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Productions -> Identity T_Productions_s24
attach_T_Productions (T_Productions
arg_tl_)) in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule252 NontermIdent
_lhsInt in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule259 NontermIdent
_lhsInt in
         let !(T_Production_vOut43 AttrMap
_hdIallAttributes T_Production_s52
_hdX52) = T_Production_s22 -> forall t. K_Production_s22 t -> t
inv_Production_s22 T_Production_s22
_hdX22 K_Production_s22 (T_Production_vIn43 -> T_Production_vOut43)
K_Production_v43 (NontermIdent -> T_Production_vIn43
T_Production_vIn43 NontermIdent
_hdOnt) in
         let !(T_Productions_vOut39 AttrMap
_tlIallAttributes T_Productions_s50
_tlX50) = T_Productions_s24 -> forall t. K_Productions_s24 t -> t
inv_Productions_s24 T_Productions_s24
_tlX24 K_Productions_s24 T_Productions_v39
K_Productions_v39 (NontermIdent -> T_Productions_vIn39
T_Productions_vIn39 NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule243 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let !__st_ :: T_Productions_s50
__st_ = T_Production_s52 -> T_Productions_s50 -> T_Productions_s50
st50 T_Production_s52
_hdX52 T_Productions_s50
_tlX50
             !__result_ :: T_Productions_vOut39
__result_ = AttrMap -> T_Productions_s50 -> T_Productions_vOut39
T_Productions_vOut39 AttrMap
_lhsOallAttributes T_Productions_s50
__st_
          in T_Productions_vOut39
__result_ )
     in (forall t. K_Productions_s24 t -> t) -> T_Productions_s24
C_Productions_s24 forall t. K_Productions_s24 t -> t
k24
   {-# NOINLINE st50 #-}
   st50 :: T_Production_s52 -> T_Productions_s50 -> T_Productions_s50
st50 = \ !T_Production_s52
_hdX52 !T_Productions_s50
_tlX50 -> let
      v40 :: T_Productions_v40 
      v40 :: T_Productions_v40
v40 = \ !(T_Productions_vIn40 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let !_hdOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_hdOaugmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule248 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn in
         let !_hdOinhMap :: Map NontermIdent Attributes
_hdOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule250 Map NontermIdent Attributes
_lhsIinhMap in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule253 Options
_lhsIoptions in
         let !_hdOsynMap :: Map NontermIdent Attributes
_hdOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule254 Map NontermIdent Attributes
_lhsIsynMap in
         let !_tlOaugmentsIn :: Map NontermIdent (Map NontermIdent [Expression])
_tlOaugmentsIn = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule255 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn in
         let !_tlOinhMap :: Map NontermIdent Attributes
_tlOinhMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule257 Map NontermIdent Attributes
_lhsIinhMap in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule260 Options
_lhsIoptions in
         let !_tlOsynMap :: Map NontermIdent Attributes
_tlOsynMap = Map NontermIdent Attributes -> Map NontermIdent Attributes
rule261 Map NontermIdent Attributes
_lhsIsynMap in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule249 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule256 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Production_vOut44 Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut Seq Error
_hdIerrors Production
_hdIoutput) = T_Production_s52 -> T_Production_v44
inv_Production_s52 T_Production_s52
_hdX52 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> Options
-> Map NontermIdent Attributes
-> T_Production_vIn44
T_Production_vIn44 Map NontermIdent (Map NontermIdent [Expression])
_hdOaugmentsIn AttrMap
_hdOforcedIrrefutables Map NontermIdent Attributes
_hdOinhMap Options
_hdOoptions Map NontermIdent Attributes
_hdOsynMap) in
         let !(T_Productions_vOut40 Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut Seq Error
_tlIerrors Productions
_tlIoutput) = T_Productions_s50 -> T_Productions_v40
inv_Productions_s50 T_Productions_s50
_tlX50 (Map NontermIdent (Map NontermIdent [Expression])
-> AttrMap
-> Map NontermIdent Attributes
-> Options
-> Map NontermIdent Attributes
-> T_Productions_vIn40
T_Productions_vIn40 Map NontermIdent (Map NontermIdent [Expression])
_tlOaugmentsIn AttrMap
_tlOforcedIrrefutables Map NontermIdent Attributes
_tlOinhMap Options
_tlOoptions Map NontermIdent Attributes
_tlOsynMap) in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule244 Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule245 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Productions
_output = Production -> Productions -> Productions
rule246 Production
_hdIoutput Productions
_tlIoutput in
         let _lhsOoutput :: Productions
             !_lhsOoutput :: Productions
_lhsOoutput = forall a. a -> a
rule247 Productions
_output in
         let !__result_ :: T_Productions_vOut40
__result_ = Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error -> Productions -> T_Productions_vOut40
T_Productions_vOut40 Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput
          in T_Productions_vOut40
__result_ )
     in T_Productions_v40 -> T_Productions_s50
C_Productions_s50 T_Productions_v40
v40
   {-# NOINLINE[1] rule243 #-}
   rule243 :: AttrMap -> AttrMap -> AttrMap
rule243 = \ ((!AttrMap
_hdIallAttributes) :: AttrMap) ((!AttrMap
_tlIallAttributes) :: AttrMap) ->
     AttrMap
_hdIallAttributes AttrMap -> AttrMap -> AttrMap
`mergeAttributes` AttrMap
_tlIallAttributes
   {-# NOINLINE[1] rule244 #-}
   rule244 :: Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule244 = \ ((!Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut) :: Map ConstructorIdent (Map Identifier [Expression])) ((!Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut) :: Map ConstructorIdent (Map Identifier [Expression])) ->
     Map NontermIdent (Map NontermIdent [Expression])
_hdIaugmentsOut forall k a. Ord k => Map k a -> Map k a -> Map k a
`Map.union` Map NontermIdent (Map NontermIdent [Expression])
_tlIaugmentsOut
   {-# NOINLINE[1] rule245 #-}
   rule245 :: Seq Error -> Seq Error -> Seq Error
rule245 = \ ((!Seq Error
_hdIerrors) :: Seq Error) ((!Seq Error
_tlIerrors) :: Seq Error) ->
     Seq Error
_hdIerrors forall a. Seq a -> Seq a -> Seq a
Seq.>< Seq Error
_tlIerrors
   {-# NOINLINE[1] rule246 #-}
   rule246 :: Production -> Productions -> Productions
rule246 = \ ((!Production
_hdIoutput) :: Production) ((!Productions
_tlIoutput) :: Productions) ->
     (:) Production
_hdIoutput Productions
_tlIoutput
   {-# NOINLINE[1] rule247 #-}
   rule247 :: p -> p
rule247 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule248 #-}
   rule248 :: Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule248 = \ ((!Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn) :: Map ConstructorIdent (Map Identifier [Expression])) ->
     Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn
   {-# NOINLINE[1] rule249 #-}
   rule249 :: AttrMap -> AttrMap
rule249 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule250 #-}
   rule250 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule250 = \ ((!Map NontermIdent Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIinhMap
   {-# NOINLINE[1] rule252 #-}
   rule252 :: NontermIdent -> NontermIdent
rule252 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule253 #-}
   rule253 :: Options -> Options
rule253 = \ ((!Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# NOINLINE[1] rule254 #-}
   rule254 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule254 = \ ((!Map NontermIdent Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIsynMap
   {-# NOINLINE[1] rule255 #-}
   rule255 :: Map NontermIdent (Map NontermIdent [Expression])
-> Map NontermIdent (Map NontermIdent [Expression])
rule255 = \ ((!Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn) :: Map ConstructorIdent (Map Identifier [Expression])) ->
     Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn
   {-# NOINLINE[1] rule256 #-}
   rule256 :: AttrMap -> AttrMap
rule256 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule257 #-}
   rule257 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule257 = \ ((!Map NontermIdent Attributes
_lhsIinhMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIinhMap
   {-# NOINLINE[1] rule259 #-}
   rule259 :: NontermIdent -> NontermIdent
rule259 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule260 #-}
   rule260 :: Options -> Options
rule260 = \ ((!Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# NOINLINE[1] rule261 #-}
   rule261 :: Map NontermIdent Attributes -> Map NontermIdent Attributes
rule261 = \ ((!Map NontermIdent Attributes
_lhsIsynMap) :: Map Identifier Attributes) ->
     Map NontermIdent Attributes
_lhsIsynMap
{-# NOINLINE sem_Productions_Nil #-}
sem_Productions_Nil ::  T_Productions 
sem_Productions_Nil :: T_Productions
sem_Productions_Nil  = Identity T_Productions_s24 -> T_Productions
T_Productions (forall (m :: * -> *) a. Monad m => a -> m a
return T_Productions_s24
st24) where
   {-# NOINLINE st24 #-}
   !st24 :: T_Productions_s24
st24 = let
      k24 :: K_Productions_s24  t -> t
      k24 :: forall t. K_Productions_s24 t -> t
k24 K_Productions_s24 t
K_Productions_v12 = T_Productions_v12
v12
      k24 K_Productions_s24 t
K_Productions_v25 = T_Productions_v25
v25
      k24 K_Productions_s24 t
K_Productions_v39 = T_Productions_v39
v39
      v12 :: T_Productions_v12 
      v12 :: T_Productions_v12
v12 = \ !(T_Productions_vIn12 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap String
_lhsImainName NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule262  () in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = forall {k} {a}. () -> Map k a
rule263  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule264  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule265  () in
         let _lhsOoutput :: Productions
             !_lhsOoutput :: Productions
_lhsOoutput = forall a. a -> a
rule266 forall a. [a]
_output in
         let !__result_ :: T_Productions_vOut12
__result_ = AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Productions
-> T_Productions_vOut12
T_Productions_vOut12 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput
          in T_Productions_vOut12
__result_ )
      v25 :: T_Productions_v25 
      v25 :: T_Productions_v25
v25 = \ !(T_Productions_vIn25 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap NontermIdent
_lhsInt Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule262  () in
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = forall {k} {a}. () -> Map k a
rule263  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule264  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule265  () in
         let _lhsOoutput :: Productions
             !_lhsOoutput :: Productions
_lhsOoutput = forall a. a -> a
rule266 forall a. [a]
_output in
         let !__result_ :: T_Productions_vOut25
__result_ = AttrMap
-> Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error
-> Productions
-> T_Productions_vOut25
T_Productions_vOut25 AttrMap
_lhsOallAttributes Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput
          in T_Productions_vOut25
__result_ )
      v39 :: T_Productions_v39 
      v39 :: T_Productions_v39
v39 = \ !(T_Productions_vIn39 NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule262  () in
         let !__st_ :: T_Productions_s50
__st_ = () -> T_Productions_s50
st50  ()
             !__result_ :: T_Productions_vOut39
__result_ = AttrMap -> T_Productions_s50 -> T_Productions_vOut39
T_Productions_vOut39 AttrMap
_lhsOallAttributes T_Productions_s50
__st_
          in T_Productions_vOut39
__result_ )
     in (forall t. K_Productions_s24 t -> t) -> T_Productions_s24
C_Productions_s24 forall t. K_Productions_s24 t -> t
k24
   {-# NOINLINE st50 #-}
   st50 :: () -> T_Productions_s50
st50 = \  (()
_ :: ()) -> let
      v40 :: T_Productions_v40 
      v40 :: T_Productions_v40
v40 = \ !(T_Productions_vIn40 Map NontermIdent (Map NontermIdent [Expression])
_lhsIaugmentsIn AttrMap
_lhsIforcedIrrefutables Map NontermIdent Attributes
_lhsIinhMap Options
_lhsIoptions Map NontermIdent Attributes
_lhsIsynMap) -> (
         let _lhsOaugmentsOut :: Map ConstructorIdent (Map Identifier [Expression])
             !_lhsOaugmentsOut :: Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut = forall {k} {a}. () -> Map k a
rule263  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule264  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule265  () in
         let _lhsOoutput :: Productions
             !_lhsOoutput :: Productions
_lhsOoutput = forall a. a -> a
rule266 forall a. [a]
_output in
         let !__result_ :: T_Productions_vOut40
__result_ = Map NontermIdent (Map NontermIdent [Expression])
-> Seq Error -> Productions -> T_Productions_vOut40
T_Productions_vOut40 Map NontermIdent (Map NontermIdent [Expression])
_lhsOaugmentsOut Seq Error
_lhsOerrors Productions
_lhsOoutput
          in T_Productions_vOut40
__result_ )
     in T_Productions_v40 -> T_Productions_s50
C_Productions_s50 T_Productions_v40
v40
   {-# NOINLINE[1] rule262 #-}
   rule262 :: () -> Map k a
rule262 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule263 #-}
   rule263 :: () -> Map k a
rule263 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule264 #-}
   rule264 :: () -> Seq a
rule264 = \  (()
_ :: ()) ->
     forall a. Seq a
Seq.empty
   {-# NOINLINE[1] rule265 #-}
   rule265 :: () -> [a]
rule265 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule266 #-}
   rule266 :: p -> p
rule266 = \ !p
_output ->
     p
_output

-- Rule --------------------------------------------------------
-- wrapper
data Inh_Rule  = Inh_Rule { Inh_Rule -> [(NontermIdent, NontermIdent)]
childInhs_Inh_Rule :: !([(Identifier, Identifier)]), Inh_Rule -> [(NontermIdent, NontermIdent)]
childSyns_Inh_Rule :: !([(Identifier, Identifier)]), Inh_Rule -> NontermIdent
con_Inh_Rule :: !(ConstructorIdent), Inh_Rule -> Set (NontermIdent, NontermIdent)
defs_Inh_Rule :: !(Set (Identifier, Identifier)), Inh_Rule -> AttrMap
forcedIrrefutables_Inh_Rule :: !(AttrMap), Inh_Rule -> NontermIdent
nt_Inh_Rule :: !(NontermIdent), Inh_Rule -> Options
options_Inh_Rule :: !(Options) }
data Syn_Rule  = Syn_Rule { Syn_Rule -> AttrMap
allAttributes_Syn_Rule :: !(AttrMap), Syn_Rule -> Set (NontermIdent, NontermIdent)
defsCollect_Syn_Rule :: !(Set (Identifier, Identifier)), Syn_Rule -> Seq Error
errors_Syn_Rule :: !(Seq Error), Syn_Rule -> Rule
output_Syn_Rule :: !(Rule) }
{-# INLINABLE wrap_Rule #-}
wrap_Rule :: T_Rule  -> Inh_Rule  -> (Syn_Rule )
wrap_Rule :: T_Rule -> Inh_Rule -> Syn_Rule
wrap_Rule !(T_Rule Identity T_Rule_s26
act) !(Inh_Rule [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Rule_s26
sem <- Identity T_Rule_s26
act
        let arg13 :: T_Rule_vIn13
arg13 = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> Options
-> T_Rule_vIn13
T_Rule_vIn13 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions
        !(T_Rule_vOut13 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rule
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Rule_s26 -> forall t. K_Rule_s26 t -> t
inv_Rule_s26 T_Rule_s26
sem K_Rule_s26 T_Rule_v13
K_Rule_v13 T_Rule_vIn13
arg13)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Rule
-> Syn_Rule
Syn_Rule AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rule
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Rule  = T_Rule {
                         T_Rule -> Identity T_Rule_s26
attach_T_Rule :: Identity (T_Rule_s26 )
                         }
data T_Rule_s26  where C_Rule_s26 :: {
                                     T_Rule_s26 -> forall t. K_Rule_s26 t -> t
inv_Rule_s26 :: !(forall t. K_Rule_s26  t -> t)
                                     } -> T_Rule_s26 
data T_Rule_s27  = C_Rule_s27
newtype T_Rule_s48  = C_Rule_s48 {
                                 T_Rule_s48 -> T_Rule_v37
inv_Rule_s48 :: (T_Rule_v37 )
                                 }
newtype T_Rule_s57  = C_Rule_s57 {
                                 T_Rule_s57 -> T_Rule_v54
inv_Rule_s57 :: (T_Rule_v54 )
                                 }
data K_Rule_s26 k  where
   K_Rule_v13 :: K_Rule_s26  (T_Rule_v13 )
   K_Rule_v36 :: K_Rule_s26  (T_Rule_v36 )
   K_Rule_v53 :: K_Rule_s26  (T_Rule_v53 )
type T_Rule_v13  = (T_Rule_vIn13 ) -> (T_Rule_vOut13 )
data T_Rule_vIn13  = T_Rule_vIn13 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent) !(Options)
data T_Rule_vOut13  = T_Rule_vOut13 !(AttrMap) !(Set (Identifier, Identifier)) !(Seq Error) !(Rule)
type T_Rule_v36  = (T_Rule_vIn36 ) -> (T_Rule_vOut36 )
data T_Rule_vIn36  = T_Rule_vIn36 !(ConstructorIdent) !(NontermIdent)
data T_Rule_vOut36  = T_Rule_vOut36 !(AttrMap) !(Set (Identifier, Identifier)) !(T_Rule_s48 )
type T_Rule_v37  = (T_Rule_vIn37 ) -> (T_Rule_vOut37 )
data T_Rule_vIn37  = T_Rule_vIn37 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(Set (Identifier, Identifier)) !(AttrMap) !(Options)
data T_Rule_vOut37  = T_Rule_vOut37 !(Seq Error) !(Rule)
type T_Rule_v53  = (T_Rule_vIn53 ) -> (T_Rule_vOut53 )
data T_Rule_vIn53  = T_Rule_vIn53 !(ConstructorIdent) !(NontermIdent)
data T_Rule_vOut53  = T_Rule_vOut53 !(AttrMap) !(T_Rule_s57 )
type T_Rule_v54  = (T_Rule_vIn54 ) -> (T_Rule_vOut54 )
data T_Rule_vIn54  = T_Rule_vIn54 
data T_Rule_vOut54  = T_Rule_vOut54 !(Set (Identifier, Identifier)) !(T_Rule_s48 )
{-# NOINLINE sem_Rule_Rule #-}
sem_Rule_Rule :: (Maybe Identifier) -> T_Pattern  -> T_Expression  -> (Bool) -> (String) -> (Bool) -> (Bool) -> (Bool) -> (Maybe Error) -> (Bool) -> T_Rule 
sem_Rule_Rule :: Maybe NontermIdent
-> T_Pattern
-> T_Expression
-> Bool
-> String
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Bool
-> T_Rule
sem_Rule_Rule !Maybe NontermIdent
arg_mbName_ T_Pattern
arg_pattern_ T_Expression
arg_rhs_ !Bool
arg_owrt_ !String
arg_origin_ !Bool
arg_explicit_ !Bool
arg_pure_ !Bool
arg_identity_ !Maybe Error
arg_mbError_ !Bool
arg_eager_ = Identity T_Rule_s26 -> T_Rule
T_Rule (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rule_s26
st26) where
   {-# NOINLINE st26 #-}
   !st26 :: T_Rule_s26
st26 = let
      k26 :: K_Rule_s26  t -> t
      k26 :: forall t. K_Rule_s26 t -> t
k26 K_Rule_s26 t
K_Rule_v13 = T_Rule_v13
v13
      k26 K_Rule_s26 t
K_Rule_v36 = T_Rule_vIn36 -> T_Rule_vOut36
v36
      k26 K_Rule_s26 t
K_Rule_v53 = T_Rule_vIn53 -> T_Rule_vOut53
v53
      v13 :: T_Rule_v13 
      v13 :: T_Rule_v13
v13 = \ !(T_Rule_vIn13 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions) -> (
         let !_patternX18 :: T_Pattern_s18
_patternX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pattern_)) in
         let !_rhsX4 :: T_Expression_s4
_rhsX4 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Expression -> Identity T_Expression_s4
attach_T_Expression (T_Expression
arg_rhs_)) in
         let !_patternOcon :: NontermIdent
_patternOcon = NontermIdent -> NontermIdent
rule275 NontermIdent
_lhsIcon in
         let !_patternOnt :: NontermIdent
_patternOnt = NontermIdent -> NontermIdent
rule278 NontermIdent
_lhsInt in
         let !_patternOchildInhs :: [(NontermIdent, NontermIdent)]
_patternOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule273 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patternOdefs :: Set (NontermIdent, NontermIdent)
_patternOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule276 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_rhsOchildInhs :: [(NontermIdent, NontermIdent)]
_rhsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule279 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_rhsOchildSyns :: [(NontermIdent, NontermIdent)]
_rhsOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule280 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_rhsOcon :: NontermIdent
_rhsOcon = NontermIdent -> NontermIdent
rule281 NontermIdent
_lhsIcon in
         let !_rhsOnt :: NontermIdent
_rhsOnt = NontermIdent -> NontermIdent
rule282 NontermIdent
_lhsInt in
         let !_rhsOoptions :: Options
_rhsOoptions = Options -> Options
rule283 Options
_lhsIoptions in
         let !_patternOforcedIrrefutables :: AttrMap
_patternOforcedIrrefutables = AttrMap -> AttrMap
rule277 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut31 AttrMap
_patternIallAttributes Set (NontermIdent, NontermIdent)
_patternIdefsCollect Seq Error
_patternIerrors Pattern
_patternIoutput) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patternX18 K_Pattern_s18 (T_Pattern_vIn31 -> T_Pattern_vOut31)
K_Pattern_v31 ([(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> T_Pattern_vIn31
T_Pattern_vIn31 [(NontermIdent, NontermIdent)]
_patternOchildInhs NontermIdent
_patternOcon Set (NontermIdent, NontermIdent)
_patternOdefs AttrMap
_patternOforcedIrrefutables NontermIdent
_patternOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule268 AttrMap
_patternIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule269 Set (NontermIdent, NontermIdent)
_patternIdefsCollect in
         let !_ruleDescr :: String
_ruleDescr = NontermIdent
-> NontermIdent -> Set (NontermIdent, NontermIdent) -> String
rule267 NontermIdent
_lhsIcon NontermIdent
_lhsInt Set (NontermIdent, NontermIdent)
_patternIdefsCollect in
         let !_rhsOruleDescr :: String
_rhsOruleDescr = forall a. a -> a
rule284 String
_ruleDescr in
         let !(T_Expression_vOut2 Seq Error
_rhsIerrors Expression
_rhsIoutput) = T_Expression_s4 -> T_Expression_v2
inv_Expression_s4 T_Expression_s4
_rhsX4 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> Options
-> String
-> T_Expression_vIn2
T_Expression_vIn2 [(NontermIdent, NontermIdent)]
_rhsOchildInhs [(NontermIdent, NontermIdent)]
_rhsOchildSyns NontermIdent
_rhsOcon NontermIdent
_rhsOnt Options
_rhsOoptions String
_rhsOruleDescr) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule270 Seq Error
_patternIerrors Seq Error
_rhsIerrors in
         let !_output :: Rule
_output = Pattern
-> Expression
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Maybe NontermIdent
-> String
-> Bool
-> Bool
-> Rule
rule271 Pattern
_patternIoutput Expression
_rhsIoutput Bool
arg_eager_ Bool
arg_explicit_ Bool
arg_identity_ Maybe Error
arg_mbError_ Maybe NontermIdent
arg_mbName_ String
arg_origin_ Bool
arg_owrt_ Bool
arg_pure_ in
         let _lhsOoutput :: Rule
             !_lhsOoutput :: Rule
_lhsOoutput = forall a. a -> a
rule272 Rule
_output in
         let !__result_ :: T_Rule_vOut13
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Rule
-> T_Rule_vOut13
T_Rule_vOut13 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rule
_lhsOoutput
          in T_Rule_vOut13
__result_ )
      v36 :: T_Rule_v36 
      v36 :: T_Rule_vIn36 -> T_Rule_vOut36
v36 = \ !(T_Rule_vIn36 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patternX18 :: T_Pattern_s18
_patternX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pattern_)) in
         let !_patternOcon :: NontermIdent
_patternOcon = NontermIdent -> NontermIdent
rule275 NontermIdent
_lhsIcon in
         let !_patternOnt :: NontermIdent
_patternOnt = NontermIdent -> NontermIdent
rule278 NontermIdent
_lhsInt in
         let !(T_Pattern_vOut41 AttrMap
_patternIallAttributes Set (NontermIdent, NontermIdent)
_patternIdefsCollect T_Pattern_s51
_patternX51) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patternX18 K_Pattern_s18 (T_Pattern_vIn41 -> T_Pattern_vOut41)
K_Pattern_v41 (NontermIdent -> NontermIdent -> T_Pattern_vIn41
T_Pattern_vIn41 NontermIdent
_patternOcon NontermIdent
_patternOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule268 AttrMap
_patternIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule269 Set (NontermIdent, NontermIdent)
_patternIdefsCollect in
         let !__st_ :: T_Rule_s48
__st_ = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Rule_s48
st48 NontermIdent
_lhsIcon NontermIdent
_lhsInt Set (NontermIdent, NontermIdent)
_patternIdefsCollect T_Pattern_s51
_patternX51
             !__result_ :: T_Rule_vOut36
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent) -> T_Rule_s48 -> T_Rule_vOut36
T_Rule_vOut36 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Rule_s48
__st_
          in T_Rule_vOut36
__result_ )
      v53 :: T_Rule_v53 
      v53 :: T_Rule_vIn53 -> T_Rule_vOut53
v53 = \ !(T_Rule_vIn53 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_patternX18 :: T_Pattern_s18
_patternX18 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Pattern -> Identity T_Pattern_s18
attach_T_Pattern (T_Pattern
arg_pattern_)) in
         let !_patternOcon :: NontermIdent
_patternOcon = NontermIdent -> NontermIdent
rule275 NontermIdent
_lhsIcon in
         let !_patternOnt :: NontermIdent
_patternOnt = NontermIdent -> NontermIdent
rule278 NontermIdent
_lhsInt in
         let !(T_Pattern_vOut55 AttrMap
_patternIallAttributes T_Pattern_s58
_patternX58) = T_Pattern_s18 -> forall t. K_Pattern_s18 t -> t
inv_Pattern_s18 T_Pattern_s18
_patternX18 K_Pattern_s18 (T_Pattern_vIn55 -> T_Pattern_vOut55)
K_Pattern_v55 (NontermIdent -> NontermIdent -> T_Pattern_vIn55
T_Pattern_vIn55 NontermIdent
_patternOcon NontermIdent
_patternOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap
rule268 AttrMap
_patternIallAttributes in
         let !__st_ :: T_Rule_s57
__st_ = NontermIdent -> NontermIdent -> T_Pattern_s58 -> T_Rule_s57
st57 NontermIdent
_lhsIcon NontermIdent
_lhsInt T_Pattern_s58
_patternX58
             !__result_ :: T_Rule_vOut53
__result_ = AttrMap -> T_Rule_s57 -> T_Rule_vOut53
T_Rule_vOut53 AttrMap
_lhsOallAttributes T_Rule_s57
__st_
          in T_Rule_vOut53
__result_ )
     in (forall t. K_Rule_s26 t -> t) -> T_Rule_s26
C_Rule_s26 forall t. K_Rule_s26 t -> t
k26
   {-# NOINLINE st48 #-}
   st48 :: NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Rule_s48
st48 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ((!NontermIdent
_lhsInt) :: NontermIdent) ((!Set (NontermIdent, NontermIdent)
_patternIdefsCollect) :: Set (Identifier, Identifier)) !T_Pattern_s51
_patternX51 -> let
      v37 :: T_Rule_v37 
      v37 :: T_Rule_v37
v37 = \ !(T_Rule_vIn37 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables Options
_lhsIoptions) -> (
         let !_rhsOcon :: NontermIdent
_rhsOcon = NontermIdent -> NontermIdent
rule281 NontermIdent
_lhsIcon in
         let !_rhsOnt :: NontermIdent
_rhsOnt = NontermIdent -> NontermIdent
rule282 NontermIdent
_lhsInt in
         let !_ruleDescr :: String
_ruleDescr = NontermIdent
-> NontermIdent -> Set (NontermIdent, NontermIdent) -> String
rule267 NontermIdent
_lhsIcon NontermIdent
_lhsInt Set (NontermIdent, NontermIdent)
_patternIdefsCollect in
         let !_rhsX4 :: T_Expression_s4
_rhsX4 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Expression -> Identity T_Expression_s4
attach_T_Expression (T_Expression
arg_rhs_)) in
         let !_patternOchildInhs :: [(NontermIdent, NontermIdent)]
_patternOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule273 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_patternOdefs :: Set (NontermIdent, NontermIdent)
_patternOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule276 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_rhsOchildInhs :: [(NontermIdent, NontermIdent)]
_rhsOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule279 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_rhsOchildSyns :: [(NontermIdent, NontermIdent)]
_rhsOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule280 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_rhsOoptions :: Options
_rhsOoptions = Options -> Options
rule283 Options
_lhsIoptions in
         let !_rhsOruleDescr :: String
_rhsOruleDescr = forall a. a -> a
rule284 String
_ruleDescr in
         let !_patternOforcedIrrefutables :: AttrMap
_patternOforcedIrrefutables = AttrMap -> AttrMap
rule277 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Pattern_vOut42 Seq Error
_patternIerrors Pattern
_patternIoutput) = T_Pattern_s51 -> T_Pattern_v42
inv_Pattern_s51 T_Pattern_s51
_patternX51 ([(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent) -> AttrMap -> T_Pattern_vIn42
T_Pattern_vIn42 [(NontermIdent, NontermIdent)]
_patternOchildInhs Set (NontermIdent, NontermIdent)
_patternOdefs AttrMap
_patternOforcedIrrefutables) in
         let !(T_Expression_vOut2 Seq Error
_rhsIerrors Expression
_rhsIoutput) = T_Expression_s4 -> T_Expression_v2
inv_Expression_s4 T_Expression_s4
_rhsX4 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> NontermIdent
-> Options
-> String
-> T_Expression_vIn2
T_Expression_vIn2 [(NontermIdent, NontermIdent)]
_rhsOchildInhs [(NontermIdent, NontermIdent)]
_rhsOchildSyns NontermIdent
_rhsOcon NontermIdent
_rhsOnt Options
_rhsOoptions String
_rhsOruleDescr) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule270 Seq Error
_patternIerrors Seq Error
_rhsIerrors in
         let !_output :: Rule
_output = Pattern
-> Expression
-> Bool
-> Bool
-> Bool
-> Maybe Error
-> Maybe NontermIdent
-> String
-> Bool
-> Bool
-> Rule
rule271 Pattern
_patternIoutput Expression
_rhsIoutput Bool
arg_eager_ Bool
arg_explicit_ Bool
arg_identity_ Maybe Error
arg_mbError_ Maybe NontermIdent
arg_mbName_ String
arg_origin_ Bool
arg_owrt_ Bool
arg_pure_ in
         let _lhsOoutput :: Rule
             !_lhsOoutput :: Rule
_lhsOoutput = forall a. a -> a
rule272 Rule
_output in
         let !__result_ :: T_Rule_vOut37
__result_ = Seq Error -> Rule -> T_Rule_vOut37
T_Rule_vOut37 Seq Error
_lhsOerrors Rule
_lhsOoutput
          in T_Rule_vOut37
__result_ )
     in T_Rule_v37 -> T_Rule_s48
C_Rule_s48 T_Rule_v37
v37
   {-# NOINLINE st57 #-}
   st57 :: NontermIdent -> NontermIdent -> T_Pattern_s58 -> T_Rule_s57
st57 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ((!NontermIdent
_lhsInt) :: NontermIdent) !T_Pattern_s58
_patternX58 -> let
      v54 :: T_Rule_v54 
      v54 :: T_Rule_v54
v54 = \ !(T_Rule_vIn54
T_Rule_vIn54 ) -> (
         let !(T_Pattern_vOut56 Set (NontermIdent, NontermIdent)
_patternIdefsCollect T_Pattern_s51
_patternX51) = T_Pattern_s58 -> T_Pattern_v56
inv_Pattern_s58 T_Pattern_s58
_patternX58 (T_Pattern_vIn56
T_Pattern_vIn56 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule269 Set (NontermIdent, NontermIdent)
_patternIdefsCollect in
         let !__st_ :: T_Rule_s48
__st_ = NontermIdent
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> T_Pattern_s51
-> T_Rule_s48
st48 NontermIdent
_lhsIcon NontermIdent
_lhsInt Set (NontermIdent, NontermIdent)
_patternIdefsCollect T_Pattern_s51
_patternX51
             !__result_ :: T_Rule_vOut54
__result_ = Set (NontermIdent, NontermIdent) -> T_Rule_s48 -> T_Rule_vOut54
T_Rule_vOut54 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Rule_s48
__st_
          in T_Rule_vOut54
__result_ )
     in T_Rule_v54 -> T_Rule_s57
C_Rule_s57 T_Rule_v54
v54
   {-# NOINLINE[1] rule267 #-}
   {-# LINE 172 "src-ag/Desugar.ag" #-}
   rule267 = \ ((!_lhsIcon) :: ConstructorIdent) ((!_lhsInt) :: NontermIdent) ((!_patternIdefsCollect) :: Set (Identifier, Identifier)) ->
                        {-# LINE 172 "src-ag/Desugar.ag" #-}
                        show _lhsInt ++ " :: " ++ show _lhsIcon ++ " :: " ++ (concat $ intersperse "," $ map (\(f,a) -> show f ++ "." ++ show a) $ Set.toList _patternIdefsCollect)
                        {-# LINE 4003 "src-generated/Desugar.hs" #-}
   {-# NOINLINE[1] rule268 #-}
   rule268 = \ ((!_patternIallAttributes) :: AttrMap) ->
     _patternIallAttributes
   {-# NOINLINE[1] rule269 #-}
   rule269 = \ ((!_patternIdefsCollect) :: Set (Identifier, Identifier)) ->
     _patternIdefsCollect
   {-# NOINLINE[1] rule270 #-}
   rule270 = \ ((!_patternIerrors) :: Seq Error) ((!_rhsIerrors) :: Seq Error) ->
     _patternIerrors Seq.>< _rhsIerrors
   {-# NOINLINE[1] rule271 #-}
   rule271 = \ ((!_patternIoutput) :: Pattern) ((!_rhsIoutput) :: Expression) !eager_ !explicit_ !identity_ !mbError_ !mbName_ !origin_ !owrt_ !pure_ ->
     Rule mbName_ _patternIoutput _rhsIoutput owrt_ origin_ explicit_ pure_ identity_ mbError_ eager_
   {-# NOINLINE[1] rule272 #-}
   rule272 = \ !_output ->
     _output
   {-# NOINLINE[1] rule273 #-}
   rule273 = \ ((!_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     _lhsIchildInhs
   {-# NOINLINE[1] rule275 #-}
   rule275 = \ ((!_lhsIcon) :: ConstructorIdent) ->
     _lhsIcon
   {-# NOINLINE[1] rule276 #-}
   rule276 = \ ((!_lhsIdefs) :: Set (Identifier, Identifier)) ->
     _lhsIdefs
   {-# NOINLINE[1] rule277 #-}
   rule277 = \ ((!_lhsIforcedIrrefutables) :: AttrMap) ->
     _lhsIforcedIrrefutables
   {-# NOINLINE[1] rule278 #-}
   rule278 = \ ((!_lhsInt) :: NontermIdent) ->
     _lhsInt
   {-# NOINLINE[1] rule279 #-}
   rule279 = \ ((!_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     _lhsIchildInhs
   {-# NOINLINE[1] rule280 #-}
   rule280 = \ ((!_lhsIchildSyns) :: [(Identifier, Identifier)]) ->
     _lhsIchildSyns
   {-# NOINLINE[1] rule281 #-}
   rule281 = \ ((!_lhsIcon) :: ConstructorIdent) ->
     _lhsIcon
   {-# NOINLINE[1] rule282 #-}
   rule282 = \ ((!_lhsInt) :: NontermIdent) ->
     _lhsInt
   {-# NOINLINE[1] rule283 #-}
   rule283 = \ ((!_lhsIoptions) :: Options) ->
     _lhsIoptions
   {-# NOINLINE[1] rule284 #-}
   rule284 = \ !_ruleDescr ->
     _ruleDescr

-- Rules -------------------------------------------------------
-- wrapper
data Inh_Rules  = Inh_Rules { Inh_Rules -> [(NontermIdent, NontermIdent)]
childInhs_Inh_Rules :: !([(Identifier, Identifier)]), Inh_Rules -> [(NontermIdent, NontermIdent)]
childSyns_Inh_Rules :: !([(Identifier, Identifier)]), Inh_Rules -> NontermIdent
con_Inh_Rules :: !(ConstructorIdent), Inh_Rules -> Set (NontermIdent, NontermIdent)
defs_Inh_Rules :: !(Set (Identifier, Identifier)), Inh_Rules -> AttrMap
forcedIrrefutables_Inh_Rules :: !(AttrMap), Inh_Rules -> NontermIdent
nt_Inh_Rules :: !(NontermIdent), Inh_Rules -> Options
options_Inh_Rules :: !(Options) }
data Syn_Rules  = Syn_Rules { Syn_Rules -> AttrMap
allAttributes_Syn_Rules :: !(AttrMap), Syn_Rules -> Set (NontermIdent, NontermIdent)
defsCollect_Syn_Rules :: !(Set (Identifier, Identifier)), Syn_Rules -> Seq Error
errors_Syn_Rules :: !(Seq Error), Syn_Rules -> Rules
output_Syn_Rules :: !(Rules) }
{-# INLINABLE wrap_Rules #-}
wrap_Rules :: T_Rules  -> Inh_Rules  -> (Syn_Rules )
wrap_Rules :: T_Rules -> Inh_Rules -> Syn_Rules
wrap_Rules !(T_Rules Identity T_Rules_s28
act) !(Inh_Rules [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_Rules_s28
sem <- Identity T_Rules_s28
act
        let arg14 :: T_Rules_vIn14
arg14 = [(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> Options
-> T_Rules_vIn14
T_Rules_vIn14 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions
        !(T_Rules_vOut14 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rules
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
sem K_Rules_s28 T_Rules_v14
K_Rules_v14 T_Rules_vIn14
arg14)
        forall (m :: * -> *) a. Monad m => a -> m a
return (AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Rules
-> Syn_Rules
Syn_Rules AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rules
_lhsOoutput)
   )

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

-- semantic domain
newtype T_Rules  = T_Rules {
                           T_Rules -> Identity T_Rules_s28
attach_T_Rules :: Identity (T_Rules_s28 )
                           }
data T_Rules_s28  where C_Rules_s28 :: {
                                       T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 :: !(forall t. K_Rules_s28  t -> t)
                                       } -> T_Rules_s28 
data T_Rules_s29  = C_Rules_s29
newtype T_Rules_s43  = C_Rules_s43 {
                                   T_Rules_s43 -> T_Rules_v29
inv_Rules_s43 :: (T_Rules_v29 )
                                   }
newtype T_Rules_s55  = C_Rules_s55 {
                                   T_Rules_s55 -> T_Rules_v50
inv_Rules_s55 :: (T_Rules_v50 )
                                   }
data K_Rules_s28 k  where
   K_Rules_v14 :: K_Rules_s28  (T_Rules_v14 )
   K_Rules_v28 :: K_Rules_s28  (T_Rules_v28 )
   K_Rules_v49 :: K_Rules_s28  (T_Rules_v49 )
type T_Rules_v14  = (T_Rules_vIn14 ) -> (T_Rules_vOut14 )
data T_Rules_vIn14  = T_Rules_vIn14 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(ConstructorIdent) !(Set (Identifier, Identifier)) !(AttrMap) !(NontermIdent) !(Options)
data T_Rules_vOut14  = T_Rules_vOut14 !(AttrMap) !(Set (Identifier, Identifier)) !(Seq Error) !(Rules)
type T_Rules_v28  = (T_Rules_vIn28 ) -> (T_Rules_vOut28 )
data T_Rules_vIn28  = T_Rules_vIn28 !(ConstructorIdent) !(NontermIdent)
data T_Rules_vOut28  = T_Rules_vOut28 !(AttrMap) !(Set (Identifier, Identifier)) !(T_Rules_s43 )
type T_Rules_v29  = (T_Rules_vIn29 ) -> (T_Rules_vOut29 )
data T_Rules_vIn29  = T_Rules_vIn29 !([(Identifier, Identifier)]) !([(Identifier, Identifier)]) !(Set (Identifier, Identifier)) !(AttrMap) !(Options)
data T_Rules_vOut29  = T_Rules_vOut29 !(Seq Error) !(Rules)
type T_Rules_v49  = (T_Rules_vIn49 ) -> (T_Rules_vOut49 )
data T_Rules_vIn49  = T_Rules_vIn49 !(ConstructorIdent) !(NontermIdent)
data T_Rules_vOut49  = T_Rules_vOut49 !(AttrMap) !(T_Rules_s55 )
type T_Rules_v50  = (T_Rules_vIn50 ) -> (T_Rules_vOut50 )
data T_Rules_vIn50  = T_Rules_vIn50 
data T_Rules_vOut50  = T_Rules_vOut50 !(Set (Identifier, Identifier)) !(T_Rules_s43 )
{-# NOINLINE sem_Rules_Cons #-}
sem_Rules_Cons :: T_Rule  -> T_Rules  -> T_Rules 
sem_Rules_Cons :: T_Rule -> T_Rules -> T_Rules
sem_Rules_Cons T_Rule
arg_hd_ T_Rules
arg_tl_ = Identity T_Rules_s28 -> T_Rules
T_Rules (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rules_s28
st28) where
   {-# NOINLINE st28 #-}
   !st28 :: T_Rules_s28
st28 = let
      k28 :: K_Rules_s28  t -> t
      k28 :: forall t. K_Rules_s28 t -> t
k28 K_Rules_s28 t
K_Rules_v14 = T_Rules_v14
v14
      k28 K_Rules_s28 t
K_Rules_v28 = T_Rules_v28
v28
      k28 K_Rules_s28 t
K_Rules_v49 = T_Rules_v49
v49
      v14 :: T_Rules_v14 
      v14 :: T_Rules_v14
v14 = \ !(T_Rules_vIn14 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions) -> (
         let !_hdX26 :: T_Rule_s26
_hdX26 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rule -> Identity T_Rule_s26
attach_T_Rule (T_Rule
arg_hd_)) in
         let !_tlX28 :: T_Rules_s28
_tlX28 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s28
attach_T_Rules (T_Rules
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule292 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule295 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule299 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule302 NontermIdent
_lhsInt in
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule290 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOchildSyns :: [(NontermIdent, NontermIdent)]
_hdOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule291 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule293 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule296 Options
_lhsIoptions in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule297 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOchildSyns :: [(NontermIdent, NontermIdent)]
_tlOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule298 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule300 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule303 Options
_lhsIoptions in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule294 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule301 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Rule_vOut13 AttrMap
_hdIallAttributes Set (NontermIdent, NontermIdent)
_hdIdefsCollect Seq Error
_hdIerrors Rule
_hdIoutput) = T_Rule_s26 -> forall t. K_Rule_s26 t -> t
inv_Rule_s26 T_Rule_s26
_hdX26 K_Rule_s26 T_Rule_v13
K_Rule_v13 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> Options
-> T_Rule_vIn13
T_Rule_vIn13 [(NontermIdent, NontermIdent)]
_hdOchildInhs [(NontermIdent, NontermIdent)]
_hdOchildSyns NontermIdent
_hdOcon Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables NontermIdent
_hdOnt Options
_hdOoptions) in
         let !(T_Rules_vOut14 AttrMap
_tlIallAttributes Set (NontermIdent, NontermIdent)
_tlIdefsCollect Seq Error
_tlIerrors Rules
_tlIoutput) = T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
_tlX28 K_Rules_s28 T_Rules_v14
K_Rules_v14 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> NontermIdent
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> NontermIdent
-> Options
-> T_Rules_vIn14
T_Rules_vIn14 [(NontermIdent, NontermIdent)]
_tlOchildInhs [(NontermIdent, NontermIdent)]
_tlOchildSyns NontermIdent
_tlOcon Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables NontermIdent
_tlOnt Options
_tlOoptions) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule285 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule286 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule287 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Rules
_output = Rule -> Rules -> Rules
rule288 Rule
_hdIoutput Rules
_tlIoutput in
         let _lhsOoutput :: Rules
             !_lhsOoutput :: Rules
_lhsOoutput = forall a. a -> a
rule289 Rules
_output in
         let !__result_ :: T_Rules_vOut14
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Rules
-> T_Rules_vOut14
T_Rules_vOut14 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rules
_lhsOoutput
          in T_Rules_vOut14
__result_ )
      v28 :: T_Rules_v28 
      v28 :: T_Rules_v28
v28 = \ !(T_Rules_vIn28 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_hdX26 :: T_Rule_s26
_hdX26 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rule -> Identity T_Rule_s26
attach_T_Rule (T_Rule
arg_hd_)) in
         let !_tlX28 :: T_Rules_s28
_tlX28 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s28
attach_T_Rules (T_Rules
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule292 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule295 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule299 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule302 NontermIdent
_lhsInt in
         let !(T_Rule_vOut36 AttrMap
_hdIallAttributes Set (NontermIdent, NontermIdent)
_hdIdefsCollect T_Rule_s48
_hdX48) = T_Rule_s26 -> forall t. K_Rule_s26 t -> t
inv_Rule_s26 T_Rule_s26
_hdX26 K_Rule_s26 (T_Rule_vIn36 -> T_Rule_vOut36)
K_Rule_v36 (NontermIdent -> NontermIdent -> T_Rule_vIn36
T_Rule_vIn36 NontermIdent
_hdOcon NontermIdent
_hdOnt) in
         let !(T_Rules_vOut28 AttrMap
_tlIallAttributes Set (NontermIdent, NontermIdent)
_tlIdefsCollect T_Rules_s43
_tlX43) = T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
_tlX28 K_Rules_s28 T_Rules_v28
K_Rules_v28 (NontermIdent -> NontermIdent -> T_Rules_vIn28
T_Rules_vIn28 NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule285 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule286 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let !__st_ :: T_Rules_s43
__st_ = T_Rule_s48 -> T_Rules_s43 -> T_Rules_s43
st43 T_Rule_s48
_hdX48 T_Rules_s43
_tlX43
             !__result_ :: T_Rules_vOut28
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Rules_s43
-> T_Rules_vOut28
T_Rules_vOut28 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Rules_s43
__st_
          in T_Rules_vOut28
__result_ )
      v49 :: T_Rules_v49 
      v49 :: T_Rules_v49
v49 = \ !(T_Rules_vIn49 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let !_hdX26 :: T_Rule_s26
_hdX26 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rule -> Identity T_Rule_s26
attach_T_Rule (T_Rule
arg_hd_)) in
         let !_tlX28 :: T_Rules_s28
_tlX28 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_Rules -> Identity T_Rules_s28
attach_T_Rules (T_Rules
arg_tl_)) in
         let !_hdOcon :: NontermIdent
_hdOcon = NontermIdent -> NontermIdent
rule292 NontermIdent
_lhsIcon in
         let !_hdOnt :: NontermIdent
_hdOnt = NontermIdent -> NontermIdent
rule295 NontermIdent
_lhsInt in
         let !_tlOcon :: NontermIdent
_tlOcon = NontermIdent -> NontermIdent
rule299 NontermIdent
_lhsIcon in
         let !_tlOnt :: NontermIdent
_tlOnt = NontermIdent -> NontermIdent
rule302 NontermIdent
_lhsInt in
         let !(T_Rule_vOut53 AttrMap
_hdIallAttributes T_Rule_s57
_hdX57) = T_Rule_s26 -> forall t. K_Rule_s26 t -> t
inv_Rule_s26 T_Rule_s26
_hdX26 K_Rule_s26 (T_Rule_vIn53 -> T_Rule_vOut53)
K_Rule_v53 (NontermIdent -> NontermIdent -> T_Rule_vIn53
T_Rule_vIn53 NontermIdent
_hdOcon NontermIdent
_hdOnt) in
         let !(T_Rules_vOut49 AttrMap
_tlIallAttributes T_Rules_s55
_tlX55) = T_Rules_s28 -> forall t. K_Rules_s28 t -> t
inv_Rules_s28 T_Rules_s28
_tlX28 K_Rules_s28 T_Rules_v49
K_Rules_v49 (NontermIdent -> NontermIdent -> T_Rules_vIn49
T_Rules_vIn49 NontermIdent
_tlOcon NontermIdent
_tlOnt) in
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = AttrMap -> AttrMap -> AttrMap
rule285 AttrMap
_hdIallAttributes AttrMap
_tlIallAttributes in
         let !__st_ :: T_Rules_s55
__st_ = T_Rule_s57 -> T_Rules_s55 -> T_Rules_s55
st55 T_Rule_s57
_hdX57 T_Rules_s55
_tlX55
             !__result_ :: T_Rules_vOut49
__result_ = AttrMap -> T_Rules_s55 -> T_Rules_vOut49
T_Rules_vOut49 AttrMap
_lhsOallAttributes T_Rules_s55
__st_
          in T_Rules_vOut49
__result_ )
     in (forall t. K_Rules_s28 t -> t) -> T_Rules_s28
C_Rules_s28 forall t. K_Rules_s28 t -> t
k28
   {-# NOINLINE st43 #-}
   st43 :: T_Rule_s48 -> T_Rules_s43 -> T_Rules_s43
st43 = \ !T_Rule_s48
_hdX48 !T_Rules_s43
_tlX43 -> let
      v29 :: T_Rules_v29 
      v29 :: T_Rules_v29
v29 = \ !(T_Rules_vIn29 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables Options
_lhsIoptions) -> (
         let !_hdOchildInhs :: [(NontermIdent, NontermIdent)]
_hdOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule290 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_hdOchildSyns :: [(NontermIdent, NontermIdent)]
_hdOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule291 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_hdOdefs :: Set (NontermIdent, NontermIdent)
_hdOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule293 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_hdOoptions :: Options
_hdOoptions = Options -> Options
rule296 Options
_lhsIoptions in
         let !_tlOchildInhs :: [(NontermIdent, NontermIdent)]
_tlOchildInhs = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule297 [(NontermIdent, NontermIdent)]
_lhsIchildInhs in
         let !_tlOchildSyns :: [(NontermIdent, NontermIdent)]
_tlOchildSyns = [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule298 [(NontermIdent, NontermIdent)]
_lhsIchildSyns in
         let !_tlOdefs :: Set (NontermIdent, NontermIdent)
_tlOdefs = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule300 Set (NontermIdent, NontermIdent)
_lhsIdefs in
         let !_tlOoptions :: Options
_tlOoptions = Options -> Options
rule303 Options
_lhsIoptions in
         let !_hdOforcedIrrefutables :: AttrMap
_hdOforcedIrrefutables = AttrMap -> AttrMap
rule294 AttrMap
_lhsIforcedIrrefutables in
         let !_tlOforcedIrrefutables :: AttrMap
_tlOforcedIrrefutables = AttrMap -> AttrMap
rule301 AttrMap
_lhsIforcedIrrefutables in
         let !(T_Rule_vOut37 Seq Error
_hdIerrors Rule
_hdIoutput) = T_Rule_s48 -> T_Rule_v37
inv_Rule_s48 T_Rule_s48
_hdX48 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> Options
-> T_Rule_vIn37
T_Rule_vIn37 [(NontermIdent, NontermIdent)]
_hdOchildInhs [(NontermIdent, NontermIdent)]
_hdOchildSyns Set (NontermIdent, NontermIdent)
_hdOdefs AttrMap
_hdOforcedIrrefutables Options
_hdOoptions) in
         let !(T_Rules_vOut29 Seq Error
_tlIerrors Rules
_tlIoutput) = T_Rules_s43 -> T_Rules_v29
inv_Rules_s43 T_Rules_s43
_tlX43 ([(NontermIdent, NontermIdent)]
-> [(NontermIdent, NontermIdent)]
-> Set (NontermIdent, NontermIdent)
-> AttrMap
-> Options
-> T_Rules_vIn29
T_Rules_vIn29 [(NontermIdent, NontermIdent)]
_tlOchildInhs [(NontermIdent, NontermIdent)]
_tlOchildSyns Set (NontermIdent, NontermIdent)
_tlOdefs AttrMap
_tlOforcedIrrefutables Options
_tlOoptions) in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = Seq Error -> Seq Error -> Seq Error
rule287 Seq Error
_hdIerrors Seq Error
_tlIerrors in
         let !_output :: Rules
_output = Rule -> Rules -> Rules
rule288 Rule
_hdIoutput Rules
_tlIoutput in
         let _lhsOoutput :: Rules
             !_lhsOoutput :: Rules
_lhsOoutput = forall a. a -> a
rule289 Rules
_output in
         let !__result_ :: T_Rules_vOut29
__result_ = Seq Error -> Rules -> T_Rules_vOut29
T_Rules_vOut29 Seq Error
_lhsOerrors Rules
_lhsOoutput
          in T_Rules_vOut29
__result_ )
     in T_Rules_v29 -> T_Rules_s43
C_Rules_s43 T_Rules_v29
v29
   {-# NOINLINE st55 #-}
   st55 :: T_Rule_s57 -> T_Rules_s55 -> T_Rules_s55
st55 = \ !T_Rule_s57
_hdX57 !T_Rules_s55
_tlX55 -> let
      v50 :: T_Rules_v50 
      v50 :: T_Rules_v50
v50 = \ !(T_Rules_vIn50
T_Rules_vIn50 ) -> (
         let !(T_Rule_vOut54 Set (NontermIdent, NontermIdent)
_hdIdefsCollect T_Rule_s48
_hdX48) = T_Rule_s57 -> T_Rule_v54
inv_Rule_s57 T_Rule_s57
_hdX57 (T_Rule_vIn54
T_Rule_vIn54 ) in
         let !(T_Rules_vOut50 Set (NontermIdent, NontermIdent)
_tlIdefsCollect T_Rules_s43
_tlX43) = T_Rules_s55 -> T_Rules_v50
inv_Rules_s55 T_Rules_s55
_tlX55 (T_Rules_vIn50
T_Rules_vIn50 ) in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule286 Set (NontermIdent, NontermIdent)
_hdIdefsCollect Set (NontermIdent, NontermIdent)
_tlIdefsCollect in
         let !__st_ :: T_Rules_s43
__st_ = T_Rule_s48 -> T_Rules_s43 -> T_Rules_s43
st43 T_Rule_s48
_hdX48 T_Rules_s43
_tlX43
             !__result_ :: T_Rules_vOut50
__result_ = Set (NontermIdent, NontermIdent) -> T_Rules_s43 -> T_Rules_vOut50
T_Rules_vOut50 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Rules_s43
__st_
          in T_Rules_vOut50
__result_ )
     in T_Rules_v50 -> T_Rules_s55
C_Rules_s55 T_Rules_v50
v50
   {-# NOINLINE[1] rule285 #-}
   rule285 :: AttrMap -> AttrMap -> AttrMap
rule285 = \ ((!AttrMap
_hdIallAttributes) :: AttrMap) ((!AttrMap
_tlIallAttributes) :: AttrMap) ->
     AttrMap
_hdIallAttributes AttrMap -> AttrMap -> AttrMap
`mergeAttributes` AttrMap
_tlIallAttributes
   {-# NOINLINE[1] rule286 #-}
   rule286 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule286 = \ ((!Set (NontermIdent, NontermIdent)
_hdIdefsCollect) :: Set (Identifier, Identifier)) ((!Set (NontermIdent, NontermIdent)
_tlIdefsCollect) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_hdIdefsCollect forall a. Ord a => Set a -> Set a -> Set a
`Set.union` Set (NontermIdent, NontermIdent)
_tlIdefsCollect
   {-# NOINLINE[1] rule287 #-}
   rule287 :: Seq Error -> Seq Error -> Seq Error
rule287 = \ ((!Seq Error
_hdIerrors) :: Seq Error) ((!Seq Error
_tlIerrors) :: Seq Error) ->
     Seq Error
_hdIerrors forall a. Seq a -> Seq a -> Seq a
Seq.>< Seq Error
_tlIerrors
   {-# NOINLINE[1] rule288 #-}
   rule288 :: Rule -> Rules -> Rules
rule288 = \ ((!Rule
_hdIoutput) :: Rule) ((!Rules
_tlIoutput) :: Rules) ->
     (:) Rule
_hdIoutput Rules
_tlIoutput
   {-# NOINLINE[1] rule289 #-}
   rule289 :: p -> p
rule289 = \ !p
_output ->
     p
_output
   {-# NOINLINE[1] rule290 #-}
   rule290 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule290 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildInhs
   {-# NOINLINE[1] rule291 #-}
   rule291 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule291 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildSyns) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildSyns
   {-# NOINLINE[1] rule292 #-}
   rule292 :: NontermIdent -> NontermIdent
rule292 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule293 #-}
   rule293 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule293 = \ ((!Set (NontermIdent, NontermIdent)
_lhsIdefs) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_lhsIdefs
   {-# NOINLINE[1] rule294 #-}
   rule294 :: AttrMap -> AttrMap
rule294 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule295 #-}
   rule295 :: NontermIdent -> NontermIdent
rule295 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule296 #-}
   rule296 :: Options -> Options
rule296 = \ ((!Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
   {-# NOINLINE[1] rule297 #-}
   rule297 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule297 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildInhs) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildInhs
   {-# NOINLINE[1] rule298 #-}
   rule298 :: [(NontermIdent, NontermIdent)] -> [(NontermIdent, NontermIdent)]
rule298 = \ ((![(NontermIdent, NontermIdent)]
_lhsIchildSyns) :: [(Identifier, Identifier)]) ->
     [(NontermIdent, NontermIdent)]
_lhsIchildSyns
   {-# NOINLINE[1] rule299 #-}
   rule299 :: NontermIdent -> NontermIdent
rule299 = \ ((!NontermIdent
_lhsIcon) :: ConstructorIdent) ->
     NontermIdent
_lhsIcon
   {-# NOINLINE[1] rule300 #-}
   rule300 :: Set (NontermIdent, NontermIdent)
-> Set (NontermIdent, NontermIdent)
rule300 = \ ((!Set (NontermIdent, NontermIdent)
_lhsIdefs) :: Set (Identifier, Identifier)) ->
     Set (NontermIdent, NontermIdent)
_lhsIdefs
   {-# NOINLINE[1] rule301 #-}
   rule301 :: AttrMap -> AttrMap
rule301 = \ ((!AttrMap
_lhsIforcedIrrefutables) :: AttrMap) ->
     AttrMap
_lhsIforcedIrrefutables
   {-# NOINLINE[1] rule302 #-}
   rule302 :: NontermIdent -> NontermIdent
rule302 = \ ((!NontermIdent
_lhsInt) :: NontermIdent) ->
     NontermIdent
_lhsInt
   {-# NOINLINE[1] rule303 #-}
   rule303 :: Options -> Options
rule303 = \ ((!Options
_lhsIoptions) :: Options) ->
     Options
_lhsIoptions
{-# NOINLINE sem_Rules_Nil #-}
sem_Rules_Nil ::  T_Rules 
sem_Rules_Nil :: T_Rules
sem_Rules_Nil  = Identity T_Rules_s28 -> T_Rules
T_Rules (forall (m :: * -> *) a. Monad m => a -> m a
return T_Rules_s28
st28) where
   {-# NOINLINE st28 #-}
   !st28 :: T_Rules_s28
st28 = let
      k28 :: K_Rules_s28  t -> t
      k28 :: forall t. K_Rules_s28 t -> t
k28 K_Rules_s28 t
K_Rules_v14 = T_Rules_v14
v14
      k28 K_Rules_s28 t
K_Rules_v28 = T_Rules_v28
v28
      k28 K_Rules_s28 t
K_Rules_v49 = T_Rules_v49
v49
      v14 :: T_Rules_v14 
      v14 :: T_Rules_v14
v14 = \ !(T_Rules_vIn14 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns NontermIdent
_lhsIcon Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables NontermIdent
_lhsInt Options
_lhsIoptions) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule304  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule305  () in
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule306  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule307  () in
         let _lhsOoutput :: Rules
             !_lhsOoutput :: Rules
_lhsOoutput = forall a. a -> a
rule308 forall a. [a]
_output in
         let !__result_ :: T_Rules_vOut14
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> Seq Error
-> Rules
-> T_Rules_vOut14
T_Rules_vOut14 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect Seq Error
_lhsOerrors Rules
_lhsOoutput
          in T_Rules_vOut14
__result_ )
      v28 :: T_Rules_v28 
      v28 :: T_Rules_v28
v28 = \ !(T_Rules_vIn28 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule304  () in
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule305  () in
         let !__st_ :: T_Rules_s43
__st_ = () -> T_Rules_s43
st43  ()
             !__result_ :: T_Rules_vOut28
__result_ = AttrMap
-> Set (NontermIdent, NontermIdent)
-> T_Rules_s43
-> T_Rules_vOut28
T_Rules_vOut28 AttrMap
_lhsOallAttributes Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Rules_s43
__st_
          in T_Rules_vOut28
__result_ )
      v49 :: T_Rules_v49 
      v49 :: T_Rules_v49
v49 = \ !(T_Rules_vIn49 NontermIdent
_lhsIcon NontermIdent
_lhsInt) -> (
         let _lhsOallAttributes :: AttrMap
             !_lhsOallAttributes :: AttrMap
_lhsOallAttributes = forall {k} {a}. () -> Map k a
rule304  () in
         let !__st_ :: T_Rules_s55
__st_ = () -> T_Rules_s55
st55  ()
             !__result_ :: T_Rules_vOut49
__result_ = AttrMap -> T_Rules_s55 -> T_Rules_vOut49
T_Rules_vOut49 AttrMap
_lhsOallAttributes T_Rules_s55
__st_
          in T_Rules_vOut49
__result_ )
     in (forall t. K_Rules_s28 t -> t) -> T_Rules_s28
C_Rules_s28 forall t. K_Rules_s28 t -> t
k28
   {-# NOINLINE st43 #-}
   st43 :: () -> T_Rules_s43
st43 = \  (()
_ :: ()) -> let
      v29 :: T_Rules_v29 
      v29 :: T_Rules_v29
v29 = \ !(T_Rules_vIn29 [(NontermIdent, NontermIdent)]
_lhsIchildInhs [(NontermIdent, NontermIdent)]
_lhsIchildSyns Set (NontermIdent, NontermIdent)
_lhsIdefs AttrMap
_lhsIforcedIrrefutables Options
_lhsIoptions) -> (
         let _lhsOerrors :: Seq Error
             !_lhsOerrors :: Seq Error
_lhsOerrors = forall {a}. () -> Seq a
rule306  () in
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule307  () in
         let _lhsOoutput :: Rules
             !_lhsOoutput :: Rules
_lhsOoutput = forall a. a -> a
rule308 forall a. [a]
_output in
         let !__result_ :: T_Rules_vOut29
__result_ = Seq Error -> Rules -> T_Rules_vOut29
T_Rules_vOut29 Seq Error
_lhsOerrors Rules
_lhsOoutput
          in T_Rules_vOut29
__result_ )
     in T_Rules_v29 -> T_Rules_s43
C_Rules_s43 T_Rules_v29
v29
   {-# NOINLINE st55 #-}
   st55 :: () -> T_Rules_s55
st55 = \  (()
_ :: ()) -> let
      v50 :: T_Rules_v50 
      v50 :: T_Rules_v50
v50 = \ !(T_Rules_vIn50
T_Rules_vIn50 ) -> (
         let _lhsOdefsCollect :: Set (Identifier, Identifier)
             !_lhsOdefsCollect :: Set (NontermIdent, NontermIdent)
_lhsOdefsCollect = forall {a}. () -> Set a
rule305  () in
         let !__st_ :: T_Rules_s43
__st_ = () -> T_Rules_s43
st43  ()
             !__result_ :: T_Rules_vOut50
__result_ = Set (NontermIdent, NontermIdent) -> T_Rules_s43 -> T_Rules_vOut50
T_Rules_vOut50 Set (NontermIdent, NontermIdent)
_lhsOdefsCollect T_Rules_s43
__st_
          in T_Rules_vOut50
__result_ )
     in T_Rules_v50 -> T_Rules_s55
C_Rules_s55 T_Rules_v50
v50
   {-# NOINLINE[1] rule304 #-}
   rule304 :: () -> Map k a
rule304 = \  (()
_ :: ()) ->
     forall k a. Map k a
Map.empty
   {-# NOINLINE[1] rule305 #-}
   rule305 :: () -> Set a
rule305 = \  (()
_ :: ()) ->
     forall a. Set a
Set.empty
   {-# NOINLINE[1] rule306 #-}
   rule306 :: () -> Seq a
rule306 = \  (()
_ :: ()) ->
     forall a. Seq a
Seq.empty
   {-# NOINLINE[1] rule307 #-}
   rule307 :: () -> [a]
rule307 = \  (()
_ :: ()) ->
     []
   {-# NOINLINE[1] rule308 #-}
   rule308 :: p -> p
rule308 = \ !p
_output ->
     p
_output

-- TypeSig -----------------------------------------------------
-- wrapper
data Inh_TypeSig  = Inh_TypeSig {  }
data Syn_TypeSig  = Syn_TypeSig { Syn_TypeSig -> TypeSig
output_Syn_TypeSig :: !(TypeSig) }
{-# INLINABLE wrap_TypeSig #-}
wrap_TypeSig :: T_TypeSig  -> Inh_TypeSig  -> (Syn_TypeSig )
wrap_TypeSig :: T_TypeSig -> Inh_TypeSig -> Syn_TypeSig
wrap_TypeSig !(T_TypeSig Identity T_TypeSig_s30
act) !(Inh_TypeSig
Inh_TypeSig ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_TypeSig_s30
sem <- Identity T_TypeSig_s30
act
        let arg15 :: T_TypeSig_vIn15
arg15 = T_TypeSig_vIn15
T_TypeSig_vIn15 
        !(T_TypeSig_vOut15 TypeSig
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_TypeSig_s30 -> T_TypeSig_v15
inv_TypeSig_s30 T_TypeSig_s30
sem T_TypeSig_vIn15
arg15)
        forall (m :: * -> *) a. Monad m => a -> m a
return (TypeSig -> Syn_TypeSig
Syn_TypeSig TypeSig
_lhsOoutput)
   )

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

-- semantic domain
newtype T_TypeSig  = T_TypeSig {
                               T_TypeSig -> Identity T_TypeSig_s30
attach_T_TypeSig :: Identity (T_TypeSig_s30 )
                               }
newtype T_TypeSig_s30  = C_TypeSig_s30 {
                                       T_TypeSig_s30 -> T_TypeSig_v15
inv_TypeSig_s30 :: (T_TypeSig_v15 )
                                       }
data T_TypeSig_s31  = C_TypeSig_s31
type T_TypeSig_v15  = (T_TypeSig_vIn15 ) -> (T_TypeSig_vOut15 )
data T_TypeSig_vIn15  = T_TypeSig_vIn15 
data T_TypeSig_vOut15  = T_TypeSig_vOut15 !(TypeSig)
{-# NOINLINE sem_TypeSig_TypeSig #-}
sem_TypeSig_TypeSig :: (Identifier) -> (Type) -> T_TypeSig 
sem_TypeSig_TypeSig :: NontermIdent -> Type -> T_TypeSig
sem_TypeSig_TypeSig !NontermIdent
arg_name_ !Type
arg_tp_ = Identity T_TypeSig_s30 -> T_TypeSig
T_TypeSig (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSig_s30
st30) where
   {-# NOINLINE st30 #-}
   !st30 :: T_TypeSig_s30
st30 = let
      v15 :: T_TypeSig_v15 
      v15 :: T_TypeSig_v15
v15 = \ !(T_TypeSig_vIn15
T_TypeSig_vIn15 ) -> (
         let !_output :: TypeSig
_output = NontermIdent -> Type -> TypeSig
rule309 NontermIdent
arg_name_ Type
arg_tp_ in
         let _lhsOoutput :: TypeSig
             !_lhsOoutput :: TypeSig
_lhsOoutput = forall a. a -> a
rule310 TypeSig
_output in
         let !__result_ :: T_TypeSig_vOut15
__result_ = TypeSig -> T_TypeSig_vOut15
T_TypeSig_vOut15 TypeSig
_lhsOoutput
          in T_TypeSig_vOut15
__result_ )
     in T_TypeSig_v15 -> T_TypeSig_s30
C_TypeSig_s30 T_TypeSig_v15
v15
   {-# INLINE rule309 #-}
   rule309 :: NontermIdent -> Type -> TypeSig
rule309 = \ !NontermIdent
name_ !Type
tp_ ->
     NontermIdent -> Type -> TypeSig
TypeSig NontermIdent
name_ Type
tp_
   {-# INLINE rule310 #-}
   rule310 :: p -> p
rule310 = \ !p
_output ->
     p
_output

-- TypeSigs ----------------------------------------------------
-- wrapper
data Inh_TypeSigs  = Inh_TypeSigs {  }
data Syn_TypeSigs  = Syn_TypeSigs { Syn_TypeSigs -> TypeSigs
output_Syn_TypeSigs :: !(TypeSigs) }
{-# INLINABLE wrap_TypeSigs #-}
wrap_TypeSigs :: T_TypeSigs  -> Inh_TypeSigs  -> (Syn_TypeSigs )
wrap_TypeSigs :: T_TypeSigs -> Inh_TypeSigs -> Syn_TypeSigs
wrap_TypeSigs !(T_TypeSigs Identity T_TypeSigs_s32
act) !(Inh_TypeSigs
Inh_TypeSigs ) =
   forall a. Identity a -> a
Control.Monad.Identity.runIdentity (
     do !T_TypeSigs_s32
sem <- Identity T_TypeSigs_s32
act
        let arg16 :: T_TypeSigs_vIn16
arg16 = T_TypeSigs_vIn16
T_TypeSigs_vIn16 
        !(T_TypeSigs_vOut16 TypeSigs
_lhsOoutput) <- forall (m :: * -> *) a. Monad m => a -> m a
return (T_TypeSigs_s32 -> T_TypeSigs_v16
inv_TypeSigs_s32 T_TypeSigs_s32
sem T_TypeSigs_vIn16
arg16)
        forall (m :: * -> *) a. Monad m => a -> m a
return (TypeSigs -> Syn_TypeSigs
Syn_TypeSigs TypeSigs
_lhsOoutput)
   )

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

-- semantic domain
newtype T_TypeSigs  = T_TypeSigs {
                                 T_TypeSigs -> Identity T_TypeSigs_s32
attach_T_TypeSigs :: Identity (T_TypeSigs_s32 )
                                 }
newtype T_TypeSigs_s32  = C_TypeSigs_s32 {
                                         T_TypeSigs_s32 -> T_TypeSigs_v16
inv_TypeSigs_s32 :: (T_TypeSigs_v16 )
                                         }
data T_TypeSigs_s33  = C_TypeSigs_s33
type T_TypeSigs_v16  = (T_TypeSigs_vIn16 ) -> (T_TypeSigs_vOut16 )
data T_TypeSigs_vIn16  = T_TypeSigs_vIn16 
data T_TypeSigs_vOut16  = T_TypeSigs_vOut16 !(TypeSigs)
{-# NOINLINE sem_TypeSigs_Cons #-}
sem_TypeSigs_Cons :: T_TypeSig  -> T_TypeSigs  -> T_TypeSigs 
sem_TypeSigs_Cons :: T_TypeSig -> T_TypeSigs -> T_TypeSigs
sem_TypeSigs_Cons T_TypeSig
arg_hd_ T_TypeSigs
arg_tl_ = Identity T_TypeSigs_s32 -> T_TypeSigs
T_TypeSigs (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSigs_s32
st32) where
   {-# NOINLINE st32 #-}
   !st32 :: T_TypeSigs_s32
st32 = let
      v16 :: T_TypeSigs_v16 
      v16 :: T_TypeSigs_v16
v16 = \ !(T_TypeSigs_vIn16
T_TypeSigs_vIn16 ) -> (
         let !_hdX30 :: T_TypeSig_s30
_hdX30 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSig -> Identity T_TypeSig_s30
attach_T_TypeSig (T_TypeSig
arg_hd_)) in
         let !_tlX32 :: T_TypeSigs_s32
_tlX32 = forall a. Identity a -> a
Control.Monad.Identity.runIdentity (T_TypeSigs -> Identity T_TypeSigs_s32
attach_T_TypeSigs (T_TypeSigs
arg_tl_)) in
         let !(T_TypeSig_vOut15 TypeSig
_hdIoutput) = T_TypeSig_s30 -> T_TypeSig_v15
inv_TypeSig_s30 T_TypeSig_s30
_hdX30 (T_TypeSig_vIn15
T_TypeSig_vIn15 ) in
         let !(T_TypeSigs_vOut16 TypeSigs
_tlIoutput) = T_TypeSigs_s32 -> T_TypeSigs_v16
inv_TypeSigs_s32 T_TypeSigs_s32
_tlX32 (T_TypeSigs_vIn16
T_TypeSigs_vIn16 ) in
         let !_output :: TypeSigs
_output = TypeSig -> TypeSigs -> TypeSigs
rule311 TypeSig
_hdIoutput TypeSigs
_tlIoutput in
         let _lhsOoutput :: TypeSigs
             !_lhsOoutput :: TypeSigs
_lhsOoutput = forall a. a -> a
rule312 TypeSigs
_output in
         let !__result_ :: T_TypeSigs_vOut16
__result_ = TypeSigs -> T_TypeSigs_vOut16
T_TypeSigs_vOut16 TypeSigs
_lhsOoutput
          in T_TypeSigs_vOut16
__result_ )
     in T_TypeSigs_v16 -> T_TypeSigs_s32
C_TypeSigs_s32 T_TypeSigs_v16
v16
   {-# INLINE rule311 #-}
   rule311 :: TypeSig -> TypeSigs -> TypeSigs
rule311 = \ ((!TypeSig
_hdIoutput) :: TypeSig) ((!TypeSigs
_tlIoutput) :: TypeSigs) ->
     (:) TypeSig
_hdIoutput TypeSigs
_tlIoutput
   {-# INLINE rule312 #-}
   rule312 :: p -> p
rule312 = \ !p
_output ->
     p
_output
{-# NOINLINE sem_TypeSigs_Nil #-}
sem_TypeSigs_Nil ::  T_TypeSigs 
sem_TypeSigs_Nil :: T_TypeSigs
sem_TypeSigs_Nil  = Identity T_TypeSigs_s32 -> T_TypeSigs
T_TypeSigs (forall (m :: * -> *) a. Monad m => a -> m a
return T_TypeSigs_s32
st32) where
   {-# NOINLINE st32 #-}
   !st32 :: T_TypeSigs_s32
st32 = let
      v16 :: T_TypeSigs_v16 
      v16 :: T_TypeSigs_v16
v16 = \ !(T_TypeSigs_vIn16
T_TypeSigs_vIn16 ) -> (
         let !_output :: [a]
_output = forall {a}. () -> [a]
rule313  () in
         let _lhsOoutput :: TypeSigs
             !_lhsOoutput :: TypeSigs
_lhsOoutput = forall a. a -> a
rule314 forall a. [a]
_output in
         let !__result_ :: T_TypeSigs_vOut16
__result_ = TypeSigs -> T_TypeSigs_vOut16
T_TypeSigs_vOut16 TypeSigs
_lhsOoutput
          in T_TypeSigs_vOut16
__result_ )
     in T_TypeSigs_v16 -> T_TypeSigs_s32
C_TypeSigs_s32 T_TypeSigs_v16
v16
   {-# INLINE rule313 #-}
   rule313 :: () -> [a]
rule313 = \  (()
_ :: ()) ->
     []
   {-# INLINE rule314 #-}
   rule314 :: p -> p
rule314 = \ !p
_output ->
     p
_output