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

module Helium.StaticAnalysis.Inferencers.TypeInferencing where


-- types
import Top.Types
import Helium.StaticAnalysis.Miscellaneous.TypeConversion

-- error messages and warnings
import Helium.StaticAnalysis.Messages.Messages
import Helium.StaticAnalysis.Messages.TypeErrors
import Helium.StaticAnalysis.Messages.Warnings
import Helium.StaticAnalysis.Miscellaneous.ConstraintInfo
import Helium.StaticAnalysis.Miscellaneous.DoublyLinkedTree
import Helium.StaticAnalysis.Miscellaneous.UHA_Source

-- constraints and constraint trees
import Helium.StaticAnalysis.Miscellaneous.TypeConstraints
import Top.Ordering.Tree

-- constraint solving

import Helium.StaticAnalysis.Inferencers.SelectConstraintSolver (selectConstraintSolver)
import Top.Solver (SolveResult(..), LogEntries)
import Helium.StaticAnalysis.Heuristics.HeuristicsInfo (makeUnifier, skip_UHA_FB_RHS)
import Helium.StaticAnalysis.Inferencers.BindingGroupAnalysis


-- UHA syntax
import Helium.Syntax.UHA_Syntax
import Helium.Syntax.UHA_Range                 
         
-- other

import Helium.Utils.Utils (internalError, hole)
import Helium.ModuleSystem.ImportEnvironment  hiding (setTypeSynonyms)
import Helium.ModuleSystem.DictionaryEnvironment
import Helium.Main.Args

-- standard
import qualified Data.Map as M
import Data.Maybe 



import Data.List
import Helium.StaticAnalysis.Directives.Matchers
import Helium.StaticAnalysis.Directives.TS_Apply (applyTypingStrategy, matchInformation)
import Helium.StaticAnalysis.Directives.TS_CoreSyntax
import Helium.StaticAnalysis.Directives.TS_Attributes



import Helium.Syntax.UHA_Utils
import Control.Monad.Identity (Identity)
import qualified Control.Monad.Identity

typeInferencing :: [Option] -> ImportEnvironment -> Module
                      -> (IO (), DictionaryEnvironment, TypeEnvironment, TypeErrors, Warnings)
typeInferencing options importEnv module_ =
   let res = wrap_Module (sem_Module module_) Inh_Module {
       	         importEnvironment_Inh_Module = importEnv,
		 options_Inh_Module = options }
       debugIO = putStrLn (show $ logEntries_Syn_Module res)
   in (debugIO, dictionaryEnvironment_Syn_Module res, toplevelTypes_Syn_Module res, typeErrors_Syn_Module res, warnings_Syn_Module res)

proximaTypeInferencing :: [Option] -> ImportEnvironment -> Module
                      -> (TypeErrors, Warnings, TypeEnvironment, [(Range, TpScheme)])  
proximaTypeInferencing options importEnv module_ =
   let res = wrap_Module (sem_Module module_) Inh_Module {
       	         importEnvironment_Inh_Module = importEnv,
		 options_Inh_Module = options }
       localTypeSchemes = typeSchemesInInfoTree (substitutionFromResult $ solveResult_Syn_Module res)
                                                (qualifiersFromResult $ solveResult_Syn_Module res) 
                                                (infoTree_Syn_Module res)
   in (typeErrors_Syn_Module res, warnings_Syn_Module res, toplevelTypes_Syn_Module res, localTypeSchemes)

         
getRequiredDictionaries :: OrderedTypeSynonyms -> Tp -> TpScheme -> Predicates
getRequiredDictionaries synonyms useType defType =
   expandPredicates synonyms (matchTypeWithScheme synonyms useType defType)

matchTypeWithScheme :: OrderedTypeSynonyms -> Tp -> TpScheme -> Predicates
matchTypeWithScheme synonyms tp scheme =
   let (ips, itp) = split . snd . instantiate 0 . freezeFTV $ scheme
   in case mguWithTypeSynonyms synonyms itp (freezeVariablesInType tp) of
         Left _ -> internalError "TypeInferenceOverloading.ag" "matchTypeWithScheme" "no unification"
         Right (_, sub) -> 
            let f (Predicate s typ) = Predicate s (unfreezeVariablesInType $ sub |-> typ)
            in map f ips
            
resolveOverloading :: ClassEnvironment -> Name -> Predicates -> Predicates ->
                         DictionaryEnvironment -> DictionaryEnvironment
resolveOverloading classEnv name availablePredicates predicates dEnv = 
   let maybeTrees = map (makeDictionaryTree classEnv availablePredicates) predicates
   in if all isJust maybeTrees
        then addForVariable name (map fromJust maybeTrees) dEnv
        else internalError "TypeInferenceOverloading.ag" "resolveOverloading" ("cannot resolve overloading (" ++ show name ++ ")")
   
expandPredicates :: OrderedTypeSynonyms -> Predicates -> Predicates
expandPredicates synonyms = map (expandPredicate synonyms)

expandPredicate :: OrderedTypeSynonyms -> Predicate -> Predicate
expandPredicate (_, synonyms) (Predicate className tp) = Predicate className (expandType synonyms tp)


findInferredTypes :: M.Map Int (Scheme Predicates) -> M.Map Name (Sigma Predicates) -> TypeEnvironment
findInferredTypes typeschemeMap =
   let err = internalError "TypeInferenceCollect.ag" "findInferredTypes" "could not find type scheme variable"
       f :: Sigma Predicates -> TpScheme
       f (SigmaVar i)     = M.findWithDefault err i typeschemeMap
       f (SigmaScheme ts) = ts
   in M.map f
   
missingTypeSignature :: Bool -> Names -> TypeEnvironment -> Warnings
missingTypeSignature topLevel simplePats = 
   let -- for the moment, only missing type signature for top-level functions are reported (unless monomorphic).
      makeWarning (name, scheme) =
         let fromSimple = name `elem` simplePats && isOverloaded scheme
         in [ NoTypeDef name scheme topLevel fromSimple | null (ftv scheme) && (topLevel || fromSimple)  ]
   in concatMap makeWarning . M.assocs
   
restrictedNameErrors :: TypeEnvironment -> Names -> TypeErrors
restrictedNameErrors env = 
   let f name = case M.lookup name env of
                   Just scheme -> [ makeRestrictedButOverloadedError name scheme | isOverloaded scheme ]
                   Nothing     -> []
   in concatMap f



makeLocalTypeEnv :: TypeEnvironment -> BindingGroups -> M.Map NameWithRange TpScheme
makeLocalTypeEnv local groups =
   let (environment, _, _) = concatBindingGroups groups
       names = M.keys environment
       f x   = maybe err id (find (==x) names) 
       err   = internalError "TypeInferenceCollect.ag" "makeLocalTypeEnv" "could not find name"
   in M.fromList [ (NameWithRange (f name), scheme) | (name, scheme) <- M.assocs local ]


isSimplePattern :: Pattern -> Bool
isSimplePattern pattern =
   case pattern of
      Pattern_Variable _ _ -> True
      Pattern_Parenthesized  _ p -> isSimplePattern p
      _ -> False


globalInfoError :: a
globalInfoError = internalError "GlobalInfo.ag" "n/a" "global info not available"

                  
type ScopeInfo = ( [Names]          -- duplicated variables
                 , [Name]           -- unused variables
                 , [(Name, Name)]   -- shadowed variables
                 )

changeOfScope :: Names -> Names -> Names -> (Names, Names, ScopeInfo)
changeOfScope names unboundNames namesInScope = 
   let (uniqueNames, duplicatedNames) = uniqueAppearance names
       unusedNames   = uniqueNames \\ unboundNames
       shadowedNames = let f n = [ (n, n') | n' <- namesInScope, n == n' ]
                       in concatMap f uniqueNames
   in ( uniqueNames ++ map head duplicatedNames ++ (namesInScope \\ names)
      , unboundNames \\ names
      , (duplicatedNames, unusedNames, shadowedNames)
      )
      
uniqueAppearance :: Ord a => [a] -> ([a],[[a]])
uniqueAppearance = Prelude.foldr myInsert ([],[]) . group . sort
   where myInsert [x] (as,bs) = (x:as,bs)
         myInsert xs  (as,bs) = (as,xs:bs)
       
nextUnique :: Num a => a -> (a, a)         
nextUnique n = (n+1, n)


matchConverter0 :: [([String],())] -> ()
matchConverter0 = const ()

matchConverter1 :: [([String],a)] -> [(a,[String])]
matchConverter1 = map (\(a,b) -> (b,a))  
                  
matchConverter2 :: [([String],(a,b))] -> ([(a,[String])],[(b,[String])])
matchConverter2 = let localInsert (metas,(a,b)) (as,bs) = ((a,metas):as,(b,metas):bs)
                  in foldr localInsert ([],[])                  

matchConverter3 :: [([String],(a,b,c))] -> ([(a,[String])],[(b,[String])],[(c,[String])])
matchConverter3 = let localInsert (metas,(a,b,c)) (as,bs,cs) = ((a,metas):as,(b,metas):bs,(c,metas):cs)
                  in foldr localInsert ([],[],[]) 

allMatch :: [Maybe [a]] -> Maybe [a]
allMatch = rec_ []
  where rec_ xs []             = Just xs
        rec_ _  (Nothing:_)    = Nothing
        rec_ xs (Just ys:rest) = rec_ (ys ++ xs) rest

data Match a = NoMatch | NonTerminalMatch a | MetaVariableMatch String

instance Show (Match a) where
  show (NoMatch) = "NoMatch"
  show (NonTerminalMatch _) = "NonTerminal ??"
  show (MetaVariableMatch s) = "MetaVariableMatch "++show s

expressionVariableMatcher :: Expression -> Maybe String
expressionVariableMatcher expr =
   case expr of
      Expression_Variable _ name -> Just (show name)
      _                          -> Nothing

match0 :: MetaVariableInfo -> Int -> (Expression -> Maybe ())
         -> [(Expression, [String])]
         -> [((Expression, [String]), Core_TypingStrategy)]
         -> [[Maybe MetaVariableTable]]
         -> ((), [Maybe MetaVariableTable], ConstraintSet, Assumptions, Int, IO ())      
match0 = generalMatch expressionVariableMatcher matchConverter0

match1 :: MetaVariableInfo -> Int -> (Expression -> Maybe a)
         -> [(Expression, [String])]
         -> [((Expression, [String]), Core_TypingStrategy)]
         -> [[Maybe MetaVariableTable]]
         -> ([(a, [String])], [Maybe MetaVariableTable],
             ConstraintSet, Assumptions, Int, IO ())
match1 = generalMatch expressionVariableMatcher matchConverter1

match2 :: MetaVariableInfo -> Int -> (Expression -> Maybe (a, b))
         -> [(Expression, [String])]
         -> [((Expression, [String]), Core_TypingStrategy)]
         -> [[Maybe MetaVariableTable]]
         -> (([(a, [String])], [(b, [String])]), [Maybe MetaVariableTable],
             ConstraintSet, Assumptions, Int, IO ())
match2 = generalMatch expressionVariableMatcher matchConverter2

match3 :: MetaVariableInfo -> Int -> (Expression -> Maybe (a, b, c))
        -> [(Expression, [String])]
        -> [((Expression, [String]), Core_TypingStrategy)]
        -> [[Maybe MetaVariableTable]]
        -> (([(a, [String])], [(b, [String])], [(c, [String])]),
            [Maybe MetaVariableTable], ConstraintSet,
            Assumptions, Int, IO ())
match3 = generalMatch expressionVariableMatcher matchConverter3

match0' :: (a -> Maybe ()) -> [(a, [String])]
         -> [((a, [String]), Core_TypingStrategy)]
         -> [[Maybe MetaVariableTable]]
         -> ((), [Maybe MetaVariableTable], ConstraintSet,
             Assumptions, Int, IO ())
match0' = generalMatch noMatch matchConverter0 noMetaVariableInfo 0

match1' :: (a -> Maybe b) -> [(a, [String])]
         -> [((a, [String]), Core_TypingStrategy)]
         -> [[Maybe MetaVariableTable]] -> 
            ([(b, [String])], [Maybe MetaVariableTable],
             ConstraintSet, Assumptions, Int, IO ())
match1' = generalMatch noMatch matchConverter1 noMetaVariableInfo 0

match2' :: (n -> Maybe (a, b)) -> [(n, [String])]
         -> [((n, [String]), Core_TypingStrategy)]
         -> [[Maybe MetaVariableTable]]
         -> (([(a, [String])], [(b, [String])]),
             [Maybe MetaVariableTable], ConstraintSet, Assumptions, Int, IO ())
match2' = generalMatch noMatch matchConverter2 noMetaVariableInfo 0

matchOnlyVariable :: MetaVariableInfo -> [(Expression, [String])] -> [Maybe MetaVariableTable]
matchOnlyVariable infoTuple tryPats = 
       let ((),matches,_,_,_,_) = match0 infoTuple 0 noMatch tryPats [] []
   in matches

noMatch :: a -> Maybe b
noMatch = const Nothing

noMetaVariableInfo :: a
noMetaVariableInfo = internalError "PatternMatching.ag" "noMetaVariableInfo" ""

generalMatch :: (nonTerminal -> Maybe String) 
             -> ([([String], childrenTuple)] -> childrenResult)
             -> MetaVariableInfo
             -> Int
             -> (nonTerminal -> Maybe childrenTuple) 
             -> [(nonTerminal, [String])] 
             -> [((nonTerminal, [String]), Core_TypingStrategy)] 
             -> [[Maybe MetaVariableTable]] 
             -> ( childrenResult
                , [Maybe MetaVariableTable]
                , ConstraintSet
                , Assumptions
                , Int
                , IO ()
                )

generalMatch exprVarMatcher converter metaInfo unique matcher tryPats allPats childrenResults =
   let match (expr,metas) = 
          case exprVarMatcher expr of
             Just s | s `elem` metas -> MetaVariableMatch s
             _ -> case matcher expr of
                     Just x  -> NonTerminalMatch (metas,x)
                     Nothing -> NoMatch
           
       (allPatterns, allStrategies) = unzip allPats
       matchListTry = map match tryPats
       matchListNew = map match allPatterns
       
       matchNTTry  = [ x | NonTerminalMatch x <- matchListTry ]
       matchNTNew  = [ x | NonTerminalMatch x <- matchListNew ]
       forChildren = converter (matchNTTry ++ matchNTNew)
       
       numberOfTry = length matchNTTry
       (resultTry,resultNew) = unzip . map (splitAt numberOfTry) $ 
                               if null childrenResults
                                 then [repeat (Just [])]
                                 else childrenResults
       inspectMatch m (res, nts) =
          case m of
             NoMatch             -> (Nothing:res, nts)
             NonTerminalMatch _  -> (allMatch (head nts):res, tail nts)
             MetaVariableMatch s -> (Just [(s, metaInfo)]:res, nts) --  !!!
       
       result   = fst (foldr inspectMatch ([],reverse $ transpose resultTry) matchListTry)       
       complete = let (list,_) = foldr inspectMatch ([],reverse $ transpose resultNew) matchListNew
                  in [ (x, y) | (Just x, y) <- zip list allStrategies ]

       (assumptions, constraintSet, debugIO, newUnique) = 
          case complete of
          
             [] -> (getAssumptions metaInfo, getConstraintSet metaInfo, return (), unique)
             
             (childrenInfo, typingStrategy):_ 
                -> applyTypingStrategy typingStrategy metaInfo childrenInfo unique            
   in (forChildren, result, constraintSet, assumptions, newUnique, debugIO)


pmError :: String -> String -> a
pmError = internalError "PatternMatchWarnings"


expandTypeFromImportEnvironment :: ImportEnvironment -> Tp -> Tp
expandTypeFromImportEnvironment env = expandType (snd $ getOrderedTypeSynonyms env)

patternMatchWarnings :: Substitution substitution
                     => ImportEnvironment          -- the importenvironment
                     -> substitution               -- substitution that contains the real types
                     -> Tp                         -- type of the patterns, unsubstituted
                     -> (Tp -> Tps)                -- how should the type be interpreted?
                     -> [([PatternElement], Bool)] -- the patterns to be processed
                     -> Range                      -- range for the missing-warnings
                     -> Maybe Name                 -- maybe the name of the function
                     -> Bool                       -- should there be parentheses around the patterns?
                     -> [Warning]                  -- list of overlap-warnings for all of the patterns  
                     -> String                     -- description of the place where the patterns are
                     -> String                     -- symbol after the patterns
                     -> [Warning]                  -- returns: list of warnings
patternMatchWarnings impenv sub tp strip elementss rng name parens unrwars place sym
  = unreachablewarnings ++ missingwarnings
    where
      env                 = importEnvironmentToEnv impenv
      exprtype            = expandTypeFromImportEnvironment impenv $ sub |-> tp
      types               = strip exprtype
      unreachables        = unreachable impenv types $ map (\((a, _), c) -> (a, c)) $ filter (not.snd.fst) $ zip elementss [0..]
      missing             = complement  impenv types $ map fst elementss
      unreachablewarnings = map (unrwars !!) unreachables
      missingwarnings
        | null $ unMissing missing = []
        | otherwise                = [MissingPatterns rng name exprtype (map (nicePattern parens env) $ missingList missing) place sym]



----------
-- misc --
----------

-- lifted or
(|^|) :: (a -> Bool) -> (a -> Bool) -> a -> Bool
(|^|) f g x = f x || g x

----------------------------------------------
--- environments and substitution of types ---
----------------------------------------------

-- environment of constructors [(type, (constructorname, arguments))]
type Env = [(Tp, (Name, [Tp]))]

importEnvironmentToEnv :: ImportEnvironment -> [(Tp, (Name, [Tp]))]
importEnvironmentToEnv = map rearrange . M.assocs . valueConstructors

-- return the number of arguments of a constructor
-- tuples ar not in the Env so they require special treatment
nrOfArguments :: Env -> String -> Int
nrOfArguments env con | isTupleConstructor con = length con - 1
                      | otherwise = case lookup (nameFromString con) $ map snd env
                                    of Just args -> length args
                                       Nothing   -> 0

-- convert constructor to fit in an Env
rearrange :: (Name, TpScheme) -> (Tp, (Name, [Tp]))
rearrange (name, tpscheme) = let (args, res) = functionSpine $ unqualify $ unquantify tpscheme
                             in (res, (name, args))

-- get the constructors of a given type out of an Env
-- tuples ar not in the Env so they require special treatment
constructors :: ImportEnvironment -> Tp -> [(Name, [Tp])]
constructors _ (TVar _) = []
constructors impenv tp | isTupleConstructor name = [tupleconstructor]
                       | otherwise               = map expand $ concatMap (substitute tp) $ importEnvironmentToEnv impenv
  where
    name :: String
    name = unTCon $ fst $ leftSpine tp
    tupleconstructor :: (Name, [Tp])
    tupleconstructor = (nameFromString name, snd $ leftSpine tp)
    unTCon :: Tp -> String
    unTCon (TCon c) = c
    unTCon tp' = pmError "unTCon" $ "type " ++ show tp' ++ " is not a TCon"
    expand :: (Name, [Tp]) -> (Name, [Tp])
    expand (n, ts) = (n, map (expandTypeFromImportEnvironment impenv) ts)

-- check of an entry in an Env is a constructor for the given type
-- if so, return this constructor, but with variables substituted for whatever is in the given type
-- the list returns zero or one elements
-- for example: substitute (Maybe Int) (Maybe a, (Just, [a])) will return [(Just, [Int])]
substitute :: Tp -> (Tp, (Name, [Tp])) -> [(Name, [Tp])]
substitute t1 (t2, (con, args)) = let (c1, ts1) = leftSpine t1
                                      (c2, ts2) = leftSpine t2
                                      sub = listToSubstitution $ zip (map unTVar ts2) ts1
                                  in if c1 == c2
                                     then [(con, map (sub |->) args)]
                                     else []
  where
    unTVar :: Tp -> Int
    unTVar (TVar v) = v
    unTVar _ = pmError "unTVar" "type is not a TVar"

---------------------------------------------------------------
--- datastructures and functions for the solution structure ---
---------------------------------------------------------------

-- a pattern is a list of patternelements
data PatternElement = WildcardElement | InfiniteElement String | FiniteElement String deriving Eq
isInfiniteElement :: PatternElement -> Bool
isInfiniteElement (InfiniteElement _) = True
isInfiniteElement _                   = False
elementString :: PatternElement -> String
elementString (InfiniteElement s) = s
elementString (  FiniteElement s) = s
elementString _                   = []

-- needed for Pattern_List and Literal_String occurences
listPat :: [[PatternElement]] -> [PatternElement]
listPat [] = [FiniteElement "[]"]
listPat (ps:pss) = FiniteElement ":" : ps ++ listPat pss

stringPat :: String -> [PatternElement]
stringPat [] = [FiniteElement "[]"]
stringPat (c:cs) = FiniteElement ":" : InfiniteElement [c] : stringPat cs

-- tree of missing patterns
data PatternsMissing = PatternsMissing [(PatternElement, PatternsMissing)]
unMissing :: PatternsMissing -> [(PatternElement, PatternsMissing)]
unMissing (PatternsMissing l) = l

-- create a branch consisting of only wildcards
wildMissing :: Int -> PatternsMissing
wildMissing 0 = PatternsMissing []
wildMissing n = PatternsMissing [(WildcardElement, wildMissing $ n - 1)]

-- convert a missing patterns tree to a list of seperated missing patterns
missingList :: PatternsMissing -> [[PatternElement]]
missingList (PatternsMissing []) = [[]]
missingList (PatternsMissing [(d,t)]) = map (d:) $ missingList t
missingList (PatternsMissing (d:ds)) = (missingList $ PatternsMissing [d]) ++ (missingList $ PatternsMissing ds)

-------------------------------------------------------------------
--- functions to create a UHA_Pattern out of a [PatternElement] ---
-------------------------------------------------------------------

-- nice creates the actual pattern without parentheses
-- [Just, True, True, (,), Just, Nothing, False] -> [Just True, True, (Just Nothing, False)]
nicePattern :: Bool -> Env -> [PatternElement] -> [Pattern]
nicePattern b env = map (parensPattern b) . nice
  where
    nice :: [PatternElement] -> [Pattern]
    nice []             = []
    nice (WildcardElement    :ps) = Pattern_Wildcard noRange : nice ps
    nice (InfiniteElement _  :_) = pmError "nicePattern" "InfiniteElement in pattern!"
    nice (FiniteElement con:ps) =
      let rest = nice ps
          name = nameFromString con
          n    = nrOfArguments env con
      in case name 
         of Name_Identifier _ _ _                          -> Pattern_Constructor noRange name (take n rest) : drop n rest -- !!!Name
            Name_Operator   _ _ _ | con == ":"             -> case head $ tail rest -- !!!Name
                                                              of Pattern_List _ pats -> Pattern_List noRange (head rest:pats) : (tail $ tail rest)
                                                                 _ -> Pattern_InfixConstructor noRange (head rest) name (head $ tail rest) : (tail $ tail rest)
                                  | otherwise              -> Pattern_InfixConstructor noRange (head rest) name (head $ tail rest) : (tail $ tail rest)
            Name_Special    _ _ _ | isTupleConstructor con -> Pattern_Tuple noRange (take n rest) : drop n rest -- !!!Name
                                  | con == "[]"            -> Pattern_List  noRange [] : rest
                                  | otherwise              -> Pattern_Constructor noRange name (take n rest) : drop n rest

-- add parentheses to a pattern in the correct places
-- bool means: if needed, should there be parenthesis around the complete pattern?
parensPattern :: Bool -> Pattern -> Pattern
parensPattern b = if b then rap . par else fst . par
  where
    par :: Pattern -> (Pattern, Bool) -- Bool means: are parentheses needed around this pattern, shoud it be used in a more complex pattern
    par p@(Pattern_Literal          _ _    ) = (p, False)
    par p@(Pattern_Variable         _ _    ) = (p, False)
    par   (Pattern_Constructor      r n ps ) = (Pattern_Constructor r n $ map (rap.par) ps, length ps > 0)
    par   (Pattern_Parenthesized    _ p    ) = par p
    par   (Pattern_InfixConstructor r l n k) = (Pattern_InfixConstructor r (rap $ par l) n (rap $ par k), True)
    par   (Pattern_List             r ps   ) = (Pattern_List r $ map (fst.par) ps, False)
    par   (Pattern_Tuple            r ps   ) = (Pattern_Tuple r $ map (fst.par) ps, False)
    par   (Pattern_Record           _ _ _  ) = pmError "parensPattern" "Records are not supported" 
    par p@(Pattern_Negate           _ _    ) = (p, True)
    par p@(Pattern_NegateFloat      _ _    ) = (p, True)
    par   (Pattern_As               r n p  ) = (Pattern_As r n (rap $ par p), False)
    par p@(Pattern_Wildcard         _      ) = (p, False)
    par   (Pattern_Irrefutable      _ _    ) = pmError "parensPattern" "Irrefutable patterns are not supported"  
    par   (Pattern_Successor        _ _ _  ) = pmError "parensPattern" "Successors are not supported" 
    par   (Pattern_Hole             _ _    ) = error "not supported"
    rap :: (Pattern, Bool) -> Pattern
    rap (p, False) = p
    rap (p, True ) = Pattern_Parenthesized noRange p

--------------------------------------
--- finally, the algorithm itself! ---
--------------------------------------

-- returns the tree of missing patterns for a given list of patterns    
complement :: ImportEnvironment -> [Tp] -> [[PatternElement]] -> PatternsMissing
complement _   []       _      = PatternsMissing []
complement _   _        ([]:_) = PatternsMissing []
complement env (tp:tps) pss    | null $ unMissing anyComplement                              = PatternsMissing []
                               | all (((== WildcardElement) |^| isInfiniteElement).head) pss = anyComplement
                               | otherwise                                                   = finComplement
  where
    patComplement :: [[PatternElement]] -> PatternElement -> [Tp] -> PatternsMissing
    patComplement []  current typs = PatternsMissing [(current, wildMissing $ length typs)]
    patComplement patss current typs = case unMissing $ complement env typs $ map tail $ patss
                                    of []   -> PatternsMissing []
                                       tegs -> PatternsMissing [(current, PatternsMissing tegs)]
    anyComplement :: PatternsMissing
    anyComplement = patComplement (filter ((== WildcardElement).head) pss) WildcardElement tps
    conComplement :: (Name, [Tp]) -> PatternsMissing
    conComplement (con, args) = patComplement (  filter ((== FiniteElement (getNameName con)).head) pss
                                              ++ map (\ps -> FiniteElement (getNameName con) : replicate (length args) WildcardElement ++ tail ps)
                                                     (filter ((== WildcardElement).head) pss)
                                              )
                                              (FiniteElement (getNameName con)) (args ++ tps)
    finComplement :: PatternsMissing
    finComplement = case constructors env tp
                    of []   -> wildMissing $ 1 + length tps
                       cons -> PatternsMissing $ concatMap (unMissing.conComplement) cons

----------------------------
--- unreachable patterns ---
----------------------------

-- complements the list of reachable patterns
unreachable :: ImportEnvironment -> [Tp] -> [([PatternElement], Int)] -> [Int]
unreachable env tps ps = let reach = reachable env tps ps
                         in  filter (not . flip elem reach) (map snd ps)

-- determines which patterns are reachable
-- possibly multiple occurances of indices
reachable :: ImportEnvironment -> [Tp] -> [([PatternElement], Int)] -> [Int]
reachable _   []       _  = pmError "reachable" "empty type list!"
reachable env (tp:tps) ps 
  | all ((== WildcardElement).head.fst) ps = conReachable ps
  | otherwise                              = concat $ map (conReachable.conPats) $ stop cons
  where
    cons :: [PatternElement]
    cons = thin $ map (head.fst) ps
    conPats :: PatternElement -> [([PatternElement], Int)]
    conPats con = map (\(es, i) -> (fill con es, i)) $ filter (((== con) |^| (== WildcardElement)).head.fst) ps
    fill :: PatternElement -> [PatternElement] -> [PatternElement]
    fill e@(FiniteElement c) (WildcardElement : es) = e : replicate (nrOfArguments (importEnvironmentToEnv env) c) WildcardElement ++ es
    fill e                   (_               : es) = e : es
    fill _                   []                     = error "Pattern match failure in StaticAnalysis.Inferencers.reachable" 
    stop :: [PatternElement] -> [PatternElement]
    stop es | length (constructors env tp) > length es = FiniteElement "[*]" : es
            | length (constructors env tp) == 0        = FiniteElement "[*]" : es
            | otherwise                                = es
    conReachable :: [([PatternElement], Int)] -> [Int]
    conReachable [] = []
    conReachable pats 
      | null.tail.fst.head $ pats = [snd.head $ pats]
      | otherwise                 = reachable env (arguments (elementString.head.fst.head $ pats) ++ tps) 
                                            $ map (\(es, i) -> (tail es, i)) pats
    arguments :: String -> [Tp]
    arguments c = maybe [] id $ lookup c $ map (\(n, typs) -> (getNameName n, typs)) $ constructors env tp

-- remove double occurances and wildcards
thin :: [PatternElement] -> [PatternElement]
thin []                     = []
thin (WildcardElement : es) = thin es
thin (e               : es) | elem e thines =     thines
                            | otherwise     = e : thines
  where thines = thin es                            
                       
-- Alternative -------------------------------------------------
-- wrapper
data Inh_Alternative  = Inh_Alternative { allPatterns_Inh_Alternative :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Alternative :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Alternative :: (Predicates), betaLeft_Inh_Alternative :: (Tp), betaRight_Inh_Alternative :: (Tp), betaUnique_Inh_Alternative :: (Int), classEnvironment_Inh_Alternative :: (ClassEnvironment), collectErrors_Inh_Alternative :: (TypeErrors), collectWarnings_Inh_Alternative :: (Warnings), counter_Inh_Alternative :: (Int), currentChunk_Inh_Alternative :: (Int), dictionaryEnvironment_Inh_Alternative :: (DictionaryEnvironment), importEnvironment_Inh_Alternative :: (ImportEnvironment), matchIO_Inh_Alternative :: (IO ()), monos_Inh_Alternative :: (Monos), namesInScope_Inh_Alternative :: (Names), orderedTypeSynonyms_Inh_Alternative :: (OrderedTypeSynonyms), parentTree_Inh_Alternative :: (InfoTree), patternMatchWarnings_Inh_Alternative :: ([Warning]), substitution_Inh_Alternative :: (FixpointSubstitution), typeschemeMap_Inh_Alternative :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Alternative :: (Int) }
data Syn_Alternative  = Syn_Alternative { assumptions_Syn_Alternative :: (Assumptions), betaUnique_Syn_Alternative :: (Int), collectErrors_Syn_Alternative :: (TypeErrors), collectInstances_Syn_Alternative :: ([(Name, Instance)]), collectWarnings_Syn_Alternative :: (Warnings), constraints_Syn_Alternative :: (ConstraintSet), counter_Syn_Alternative :: (Int), dictionaryEnvironment_Syn_Alternative :: (DictionaryEnvironment), elements_Syn_Alternative :: ( ([PatternElement], Bool) ), infoTrees_Syn_Alternative :: (InfoTrees), matchIO_Syn_Alternative :: (IO ()), patternMatchWarnings_Syn_Alternative :: ([Warning]), self_Syn_Alternative :: (Alternative), unboundNames_Syn_Alternative :: (Names), uniqueChunk_Syn_Alternative :: (Int), unrwar_Syn_Alternative :: (Warning) }
{-# INLINABLE wrap_Alternative #-}
wrap_Alternative :: T_Alternative  -> Inh_Alternative  -> (Syn_Alternative )
wrap_Alternative (T_Alternative act) (Inh_Alternative _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar) <- return (inv_Alternative_s2 sem arg)
        return (Syn_Alternative _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar)
   )

-- cata
{-# NOINLINE sem_Alternative #-}
sem_Alternative :: Alternative  -> T_Alternative 
sem_Alternative ( Alternative_Hole range_ id_ ) = sem_Alternative_Hole ( sem_Range range_ ) id_
sem_Alternative ( Alternative_Feedback range_ feedback_ alternative_ ) = sem_Alternative_Feedback ( sem_Range range_ ) feedback_ ( sem_Alternative alternative_ )
sem_Alternative ( Alternative_Alternative range_ pattern_ righthandside_ ) = sem_Alternative_Alternative ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_RightHandSide righthandside_ )
sem_Alternative ( Alternative_Empty range_ ) = sem_Alternative_Empty ( sem_Range range_ )

-- semantic domain
newtype T_Alternative  = T_Alternative {
                                       attach_T_Alternative :: Identity (T_Alternative_s2 )
                                       }
newtype T_Alternative_s2  = C_Alternative_s2 {
                                             inv_Alternative_s2 :: (T_Alternative_v1 )
                                             }
data T_Alternative_s3  = C_Alternative_s3
type T_Alternative_v1  = (T_Alternative_vIn1 ) -> (T_Alternative_vOut1 )
data T_Alternative_vIn1  = T_Alternative_vIn1 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_Alternative_vOut1  = T_Alternative_vOut1 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) ( ([PatternElement], Bool) ) (InfoTrees) (IO ()) ([Warning]) (Alternative) (Names) (Int) (Warning)
{-# NOINLINE sem_Alternative_Hole #-}
sem_Alternative_Hole :: T_Range  -> (Integer) -> T_Alternative 
sem_Alternative_Hole arg_range_ arg_id_ = T_Alternative (return st2) where
   {-# NOINLINE st2 #-}
   st2 = let
      v1 :: T_Alternative_v1 
      v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule0  ()
         _constraints = rule1  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2  ()
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule3  ()
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule4  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule5  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule6  ()
         _self = rule7 _rangeIself arg_id_
         _lhsOself :: Alternative
         _lhsOself = rule8 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule9 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule10 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule11 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule12 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule13 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule14 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule15 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule16 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule17 _lhsIuniqueChunk
         __result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_Alternative_s2 v1
   {-# INLINE rule0 #-}
   rule0 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule1 #-}
   rule1 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule2 #-}
   rule2 = \  (_ :: ()) ->
                                      []
   {-# INLINE rule3 #-}
   rule3 = \  (_ :: ()) ->
                                         ([], False)
   {-# INLINE rule4 #-}
   rule4 = \  (_ :: ()) ->
                                         pmError "Alternative_Empty.unrwar" "empty alternative"
   {-# INLINE rule5 #-}
   rule5 = \  (_ :: ()) ->
     []
   {-# INLINE rule6 #-}
   rule6 = \  (_ :: ()) ->
     []
   {-# INLINE rule7 #-}
   rule7 = \ ((_rangeIself) :: Range) id_ ->
     Alternative_Hole _rangeIself id_
   {-# INLINE rule8 #-}
   rule8 = \ _self ->
     _self
   {-# INLINE rule9 #-}
   rule9 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule10 #-}
   rule10 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule11 #-}
   rule11 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule12 #-}
   rule12 = \ _constraints ->
     _constraints
   {-# INLINE rule13 #-}
   rule13 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule14 #-}
   rule14 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule15 #-}
   rule15 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule16 #-}
   rule16 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule17 #-}
   rule17 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Alternative_Feedback #-}
sem_Alternative_Feedback :: T_Range  -> (String) -> T_Alternative  -> T_Alternative 
sem_Alternative_Feedback arg_range_ arg_feedback_ arg_alternative_ = T_Alternative (return st2) where
   {-# NOINLINE st2 #-}
   st2 = let
      v1 :: T_Alternative_v1 
      v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _alternativeX2 = Control.Monad.Identity.runIdentity (attach_T_Alternative (arg_alternative_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Alternative_vOut1 _alternativeIassumptions _alternativeIbetaUnique _alternativeIcollectErrors _alternativeIcollectInstances _alternativeIcollectWarnings _alternativeIconstraints _alternativeIcounter _alternativeIdictionaryEnvironment _alternativeIelements _alternativeIinfoTrees _alternativeImatchIO _alternativeIpatternMatchWarnings _alternativeIself _alternativeIunboundNames _alternativeIuniqueChunk _alternativeIunrwar) = inv_Alternative_s2 _alternativeX2 (T_Alternative_vIn1 _alternativeOallPatterns _alternativeOallTypeSchemes _alternativeOavailablePredicates _alternativeObetaLeft _alternativeObetaRight _alternativeObetaUnique _alternativeOclassEnvironment _alternativeOcollectErrors _alternativeOcollectWarnings _alternativeOcounter _alternativeOcurrentChunk _alternativeOdictionaryEnvironment _alternativeOimportEnvironment _alternativeOmatchIO _alternativeOmonos _alternativeOnamesInScope _alternativeOorderedTypeSynonyms _alternativeOparentTree _alternativeOpatternMatchWarnings _alternativeOsubstitution _alternativeOtypeschemeMap _alternativeOuniqueChunk)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule18 _alternativeIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule19 _alternativeIunboundNames
         _self = rule20 _alternativeIself _rangeIself arg_feedback_
         _lhsOself :: Alternative
         _lhsOself = rule21 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule22 _alternativeIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule23 _alternativeIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule24 _alternativeIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule25 _alternativeIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule26 _alternativeIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule27 _alternativeIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule28 _alternativeIdictionaryEnvironment
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule29 _alternativeIelements
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule30 _alternativeIinfoTrees
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule31 _alternativeImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule32 _alternativeIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule33 _alternativeIuniqueChunk
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule34 _alternativeIunrwar
         _alternativeOallPatterns = rule35 _lhsIallPatterns
         _alternativeOallTypeSchemes = rule36 _lhsIallTypeSchemes
         _alternativeOavailablePredicates = rule37 _lhsIavailablePredicates
         _alternativeObetaLeft = rule38 _lhsIbetaLeft
         _alternativeObetaRight = rule39 _lhsIbetaRight
         _alternativeObetaUnique = rule40 _lhsIbetaUnique
         _alternativeOclassEnvironment = rule41 _lhsIclassEnvironment
         _alternativeOcollectErrors = rule42 _lhsIcollectErrors
         _alternativeOcollectWarnings = rule43 _lhsIcollectWarnings
         _alternativeOcounter = rule44 _lhsIcounter
         _alternativeOcurrentChunk = rule45 _lhsIcurrentChunk
         _alternativeOdictionaryEnvironment = rule46 _lhsIdictionaryEnvironment
         _alternativeOimportEnvironment = rule47 _lhsIimportEnvironment
         _alternativeOmatchIO = rule48 _lhsImatchIO
         _alternativeOmonos = rule49 _lhsImonos
         _alternativeOnamesInScope = rule50 _lhsInamesInScope
         _alternativeOorderedTypeSynonyms = rule51 _lhsIorderedTypeSynonyms
         _alternativeOparentTree = rule52 _lhsIparentTree
         _alternativeOpatternMatchWarnings = rule53 _lhsIpatternMatchWarnings
         _alternativeOsubstitution = rule54 _lhsIsubstitution
         _alternativeOtypeschemeMap = rule55 _lhsItypeschemeMap
         _alternativeOuniqueChunk = rule56 _lhsIuniqueChunk
         __result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_Alternative_s2 v1
   {-# INLINE rule18 #-}
   rule18 = \ ((_alternativeIcollectInstances) :: [(Name, Instance)]) ->
     _alternativeIcollectInstances
   {-# INLINE rule19 #-}
   rule19 = \ ((_alternativeIunboundNames) :: Names) ->
     _alternativeIunboundNames
   {-# INLINE rule20 #-}
   rule20 = \ ((_alternativeIself) :: Alternative) ((_rangeIself) :: Range) feedback_ ->
     Alternative_Feedback _rangeIself feedback_ _alternativeIself
   {-# INLINE rule21 #-}
   rule21 = \ _self ->
     _self
   {-# INLINE rule22 #-}
   rule22 = \ ((_alternativeIassumptions) :: Assumptions) ->
     _alternativeIassumptions
   {-# INLINE rule23 #-}
   rule23 = \ ((_alternativeIbetaUnique) :: Int) ->
     _alternativeIbetaUnique
   {-# INLINE rule24 #-}
   rule24 = \ ((_alternativeIcollectErrors) :: TypeErrors) ->
     _alternativeIcollectErrors
   {-# INLINE rule25 #-}
   rule25 = \ ((_alternativeIcollectWarnings) :: Warnings) ->
     _alternativeIcollectWarnings
   {-# INLINE rule26 #-}
   rule26 = \ ((_alternativeIconstraints) :: ConstraintSet) ->
     _alternativeIconstraints
   {-# INLINE rule27 #-}
   rule27 = \ ((_alternativeIcounter) :: Int) ->
     _alternativeIcounter
   {-# INLINE rule28 #-}
   rule28 = \ ((_alternativeIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _alternativeIdictionaryEnvironment
   {-# INLINE rule29 #-}
   rule29 = \ ((_alternativeIelements) ::  ([PatternElement], Bool) ) ->
     _alternativeIelements
   {-# INLINE rule30 #-}
   rule30 = \ ((_alternativeIinfoTrees) :: InfoTrees) ->
     _alternativeIinfoTrees
   {-# INLINE rule31 #-}
   rule31 = \ ((_alternativeImatchIO) :: IO ()) ->
     _alternativeImatchIO
   {-# INLINE rule32 #-}
   rule32 = \ ((_alternativeIpatternMatchWarnings) :: [Warning]) ->
     _alternativeIpatternMatchWarnings
   {-# INLINE rule33 #-}
   rule33 = \ ((_alternativeIuniqueChunk) :: Int) ->
     _alternativeIuniqueChunk
   {-# INLINE rule34 #-}
   rule34 = \ ((_alternativeIunrwar) :: Warning) ->
     _alternativeIunrwar
   {-# INLINE rule35 #-}
   rule35 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule36 #-}
   rule36 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule37 #-}
   rule37 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule38 #-}
   rule38 = \ ((_lhsIbetaLeft) :: Tp) ->
     _lhsIbetaLeft
   {-# INLINE rule39 #-}
   rule39 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule40 #-}
   rule40 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule41 #-}
   rule41 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule42 #-}
   rule42 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule43 #-}
   rule43 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule44 #-}
   rule44 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule45 #-}
   rule45 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule46 #-}
   rule46 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule47 #-}
   rule47 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule48 #-}
   rule48 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule49 #-}
   rule49 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule50 #-}
   rule50 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule51 #-}
   rule51 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule52 #-}
   rule52 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule53 #-}
   rule53 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule54 #-}
   rule54 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule55 #-}
   rule55 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule56 #-}
   rule56 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Alternative_Alternative #-}
sem_Alternative_Alternative :: T_Range  -> T_Pattern  -> T_RightHandSide  -> T_Alternative 
sem_Alternative_Alternative arg_range_ arg_pattern_ arg_righthandside_ = T_Alternative (return st2) where
   {-# NOINLINE st2 #-}
   st2 = let
      v1 :: T_Alternative_v1 
      v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         _righthandsideX149 = Control.Monad.Identity.runIdentity (attach_T_RightHandSide (arg_righthandside_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         (T_RightHandSide_vOut148 _righthandsideIassumptions _righthandsideIbetaUnique _righthandsideIcollectErrors _righthandsideIcollectInstances _righthandsideIcollectWarnings _righthandsideIconstraints _righthandsideIcounter _righthandsideIdictionaryEnvironment _righthandsideIfallthrough _righthandsideIinfoTree _righthandsideImatchIO _righthandsideIpatternMatchWarnings _righthandsideIself _righthandsideIunboundNames _righthandsideIuniqueChunk) = inv_RightHandSide_s149 _righthandsideX149 (T_RightHandSide_vIn148 _righthandsideOallPatterns _righthandsideOallTypeSchemes _righthandsideOavailablePredicates _righthandsideObetaRight _righthandsideObetaUnique _righthandsideOclassEnvironment _righthandsideOcollectErrors _righthandsideOcollectWarnings _righthandsideOcounter _righthandsideOcurrentChunk _righthandsideOdictionaryEnvironment _righthandsideOimportEnvironment _righthandsideOmatchIO _righthandsideOmonos _righthandsideOnamesInScope _righthandsideOorderedTypeSynonyms _righthandsideOparentTree _righthandsideOpatternMatchWarnings _righthandsideOsubstitution _righthandsideOtypeschemeMap _righthandsideOuniqueChunk)
         _righthandsideOmonos = rule57 _csetBinds _lhsImonos _patternIenvironment
         _constraints = rule58 _conLeft _csetBinds _patternIconstraints _righthandsideIconstraints
         _conLeft = rule59 _cinfoLeft _lhsIbetaLeft _patternIbeta
         _lhsOassumptions :: Assumptions
         (_csetBinds,_lhsOassumptions) = rule60 _cinfoBind _patternIenvironment _righthandsideIassumptions
         _cinfoLeft = rule61 _lhsIbetaLeft _lhsIparentTree _patternIinfoTree
         _cinfoBind = rule62 _lhsIparentTree _patternIenvironment
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule63 _patternIinfoTree _righthandsideIinfoTree
         (_namesInScope,_unboundNames,_scopeInfo) = rule64 _lhsInamesInScope _patternIpatVarNames _righthandsideIunboundNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule65 _unboundNames
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule66 _patternIelements _righthandsideIfallthrough
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule67 _patternIself _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule68 _righthandsideIcollectInstances
         _self = rule69 _patternIself _rangeIself _righthandsideIself
         _lhsOself :: Alternative
         _lhsOself = rule70 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule71 _righthandsideIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule72 _righthandsideIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule73 _righthandsideIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule74 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule75 _righthandsideIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule76 _righthandsideIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule77 _righthandsideImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule78 _righthandsideIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule79 _righthandsideIuniqueChunk
         _patternObetaUnique = rule80 _lhsIbetaUnique
         _patternOcounter = rule81 _lhsIcounter
         _patternOimportEnvironment = rule82 _lhsIimportEnvironment
         _patternOmonos = rule83 _lhsImonos
         _patternOnamesInScope = rule84 _namesInScope
         _patternOparentTree = rule85 _lhsIparentTree
         _patternOpatternMatchWarnings = rule86 _lhsIpatternMatchWarnings
         _righthandsideOallPatterns = rule87 _lhsIallPatterns
         _righthandsideOallTypeSchemes = rule88 _lhsIallTypeSchemes
         _righthandsideOavailablePredicates = rule89 _lhsIavailablePredicates
         _righthandsideObetaRight = rule90 _lhsIbetaRight
         _righthandsideObetaUnique = rule91 _patternIbetaUnique
         _righthandsideOclassEnvironment = rule92 _lhsIclassEnvironment
         _righthandsideOcollectErrors = rule93 _lhsIcollectErrors
         _righthandsideOcollectWarnings = rule94 _lhsIcollectWarnings
         _righthandsideOcounter = rule95 _patternIcounter
         _righthandsideOcurrentChunk = rule96 _lhsIcurrentChunk
         _righthandsideOdictionaryEnvironment = rule97 _lhsIdictionaryEnvironment
         _righthandsideOimportEnvironment = rule98 _lhsIimportEnvironment
         _righthandsideOmatchIO = rule99 _lhsImatchIO
         _righthandsideOnamesInScope = rule100 _namesInScope
         _righthandsideOorderedTypeSynonyms = rule101 _lhsIorderedTypeSynonyms
         _righthandsideOparentTree = rule102 _lhsIparentTree
         _righthandsideOpatternMatchWarnings = rule103 _patternIpatternMatchWarnings
         _righthandsideOsubstitution = rule104 _lhsIsubstitution
         _righthandsideOtypeschemeMap = rule105 _lhsItypeschemeMap
         _righthandsideOuniqueChunk = rule106 _lhsIuniqueChunk
         __result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_Alternative_s2 v1
   {-# INLINE rule57 #-}
   rule57 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
                                      M.elems _patternIenvironment ++ getMonos _csetBinds ++ _lhsImonos
   {-# INLINE rule58 #-}
   rule58 = \ _conLeft _csetBinds ((_patternIconstraints) :: ConstraintSet) ((_righthandsideIconstraints) :: ConstraintSet) ->
                                      _csetBinds .>>.
                                      Node [ _conLeft  .<. _patternIconstraints
                                           , _righthandsideIconstraints
                                           ]
   {-# INLINE rule59 #-}
   rule59 = \ _cinfoLeft ((_lhsIbetaLeft) :: Tp) ((_patternIbeta) :: Tp) ->
                                      [ (_patternIbeta .==. _lhsIbetaLeft) _cinfoLeft ]
   {-# INLINE rule60 #-}
   rule60 = \ _cinfoBind ((_patternIenvironment) :: PatternAssumptions) ((_righthandsideIassumptions) :: Assumptions) ->
                                          (_patternIenvironment .===. _righthandsideIassumptions) _cinfoBind
   {-# INLINE rule61 #-}
   rule61 = \ ((_lhsIbetaLeft) :: Tp) ((_lhsIparentTree) :: InfoTree) ((_patternIinfoTree) :: InfoTree) ->
     resultConstraint "case pattern" _patternIinfoTree
        [ Unifier (head (ftv _lhsIbetaLeft)) ("case patterns", attribute _lhsIparentTree, "case pattern") ]
   {-# INLINE rule62 #-}
   rule62 = \ ((_lhsIparentTree) :: InfoTree) ((_patternIenvironment) :: PatternAssumptions) ->
     \name -> variableConstraint "variable" (nameToUHA_Expr name)
        [ FolkloreConstraint
        , makeUnifier name "case alternative" _patternIenvironment _lhsIparentTree
        ]
   {-# INLINE rule63 #-}
   rule63 = \ ((_patternIinfoTree) :: InfoTree) ((_righthandsideIinfoTree) :: InfoTree) ->
                                      [_patternIinfoTree, _righthandsideIinfoTree]
   {-# INLINE rule64 #-}
   rule64 = \ ((_lhsInamesInScope) :: Names) ((_patternIpatVarNames) :: Names) ((_righthandsideIunboundNames) :: Names) ->
                                                                        changeOfScope _patternIpatVarNames _righthandsideIunboundNames _lhsInamesInScope
   {-# INLINE rule65 #-}
   rule65 = \ _unboundNames ->
                                             _unboundNames
   {-# INLINE rule66 #-}
   rule66 = \ ((_patternIelements) ::   [PatternElement]        ) ((_righthandsideIfallthrough) :: Bool) ->
                                         (_patternIelements, _righthandsideIfallthrough)
   {-# INLINE rule67 #-}
   rule67 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
                                         UnreachablePatternCase _rangeIself _patternIself
   {-# INLINE rule68 #-}
   rule68 = \ ((_righthandsideIcollectInstances) :: [(Name, Instance)]) ->
     _righthandsideIcollectInstances
   {-# INLINE rule69 #-}
   rule69 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ((_righthandsideIself) :: RightHandSide) ->
     Alternative_Alternative _rangeIself _patternIself _righthandsideIself
   {-# INLINE rule70 #-}
   rule70 = \ _self ->
     _self
   {-# INLINE rule71 #-}
   rule71 = \ ((_righthandsideIbetaUnique) :: Int) ->
     _righthandsideIbetaUnique
   {-# INLINE rule72 #-}
   rule72 = \ ((_righthandsideIcollectErrors) :: TypeErrors) ->
     _righthandsideIcollectErrors
   {-# INLINE rule73 #-}
   rule73 = \ ((_righthandsideIcollectWarnings) :: Warnings) ->
     _righthandsideIcollectWarnings
   {-# INLINE rule74 #-}
   rule74 = \ _constraints ->
     _constraints
   {-# INLINE rule75 #-}
   rule75 = \ ((_righthandsideIcounter) :: Int) ->
     _righthandsideIcounter
   {-# INLINE rule76 #-}
   rule76 = \ ((_righthandsideIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _righthandsideIdictionaryEnvironment
   {-# INLINE rule77 #-}
   rule77 = \ ((_righthandsideImatchIO) :: IO ()) ->
     _righthandsideImatchIO
   {-# INLINE rule78 #-}
   rule78 = \ ((_righthandsideIpatternMatchWarnings) :: [Warning]) ->
     _righthandsideIpatternMatchWarnings
   {-# INLINE rule79 #-}
   rule79 = \ ((_righthandsideIuniqueChunk) :: Int) ->
     _righthandsideIuniqueChunk
   {-# INLINE rule80 #-}
   rule80 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule81 #-}
   rule81 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule82 #-}
   rule82 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule83 #-}
   rule83 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule84 #-}
   rule84 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule85 #-}
   rule85 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule86 #-}
   rule86 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule87 #-}
   rule87 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule88 #-}
   rule88 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule89 #-}
   rule89 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule90 #-}
   rule90 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule91 #-}
   rule91 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule92 #-}
   rule92 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule93 #-}
   rule93 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule94 #-}
   rule94 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule95 #-}
   rule95 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule96 #-}
   rule96 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule97 #-}
   rule97 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule98 #-}
   rule98 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule99 #-}
   rule99 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule100 #-}
   rule100 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule101 #-}
   rule101 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule102 #-}
   rule102 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule103 #-}
   rule103 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule104 #-}
   rule104 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule105 #-}
   rule105 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule106 #-}
   rule106 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Alternative_Empty #-}
sem_Alternative_Empty :: T_Range  -> T_Alternative 
sem_Alternative_Empty arg_range_ = T_Alternative (return st2) where
   {-# NOINLINE st2 #-}
   st2 = let
      v1 :: T_Alternative_v1 
      v1 = \ (T_Alternative_vIn1 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule107  ()
         _constraints = rule108  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule109  ()
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule110  ()
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule111  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule112  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule113  ()
         _self = rule114 _rangeIself
         _lhsOself :: Alternative
         _lhsOself = rule115 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule116 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule117 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule118 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule119 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule120 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule121 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule122 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule123 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule124 _lhsIuniqueChunk
         __result_ = T_Alternative_vOut1 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_Alternative_s2 v1
   {-# INLINE rule107 #-}
   rule107 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule108 #-}
   rule108 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule109 #-}
   rule109 = \  (_ :: ()) ->
                                      []
   {-# INLINE rule110 #-}
   rule110 = \  (_ :: ()) ->
                                         ([], False)
   {-# INLINE rule111 #-}
   rule111 = \  (_ :: ()) ->
                                         pmError "Alternative_Empty.unrwar" "empty alternative"
   {-# INLINE rule112 #-}
   rule112 = \  (_ :: ()) ->
     []
   {-# INLINE rule113 #-}
   rule113 = \  (_ :: ()) ->
     []
   {-# INLINE rule114 #-}
   rule114 = \ ((_rangeIself) :: Range) ->
     Alternative_Empty _rangeIself
   {-# INLINE rule115 #-}
   rule115 = \ _self ->
     _self
   {-# INLINE rule116 #-}
   rule116 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule117 #-}
   rule117 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule118 #-}
   rule118 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule119 #-}
   rule119 = \ _constraints ->
     _constraints
   {-# INLINE rule120 #-}
   rule120 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule121 #-}
   rule121 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule122 #-}
   rule122 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule123 #-}
   rule123 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule124 #-}
   rule124 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- Alternatives ------------------------------------------------
-- wrapper
data Inh_Alternatives  = Inh_Alternatives { allPatterns_Inh_Alternatives :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Alternatives :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Alternatives :: (Predicates), betaLeft_Inh_Alternatives :: (Tp), betaRight_Inh_Alternatives :: (Tp), betaUnique_Inh_Alternatives :: (Int), classEnvironment_Inh_Alternatives :: (ClassEnvironment), collectErrors_Inh_Alternatives :: (TypeErrors), collectWarnings_Inh_Alternatives :: (Warnings), counter_Inh_Alternatives :: (Int), currentChunk_Inh_Alternatives :: (Int), dictionaryEnvironment_Inh_Alternatives :: (DictionaryEnvironment), importEnvironment_Inh_Alternatives :: (ImportEnvironment), matchIO_Inh_Alternatives :: (IO ()), monos_Inh_Alternatives :: (Monos), namesInScope_Inh_Alternatives :: (Names), orderedTypeSynonyms_Inh_Alternatives :: (OrderedTypeSynonyms), parentTree_Inh_Alternatives :: (InfoTree), patternMatchWarnings_Inh_Alternatives :: ([Warning]), substitution_Inh_Alternatives :: (FixpointSubstitution), typeschemeMap_Inh_Alternatives :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Alternatives :: (Int) }
data Syn_Alternatives  = Syn_Alternatives { assumptions_Syn_Alternatives :: (Assumptions), betaUnique_Syn_Alternatives :: (Int), collectErrors_Syn_Alternatives :: (TypeErrors), collectInstances_Syn_Alternatives :: ([(Name, Instance)]), collectWarnings_Syn_Alternatives :: (Warnings), constraintslist_Syn_Alternatives :: (ConstraintSets), counter_Syn_Alternatives :: (Int), dictionaryEnvironment_Syn_Alternatives :: (DictionaryEnvironment), elementss_Syn_Alternatives :: ([([PatternElement], Bool)]), infoTrees_Syn_Alternatives :: (InfoTrees), matchIO_Syn_Alternatives :: (IO ()), patternMatchWarnings_Syn_Alternatives :: ([Warning]), self_Syn_Alternatives :: (Alternatives), unboundNames_Syn_Alternatives :: (Names), uniqueChunk_Syn_Alternatives :: (Int), unrwars_Syn_Alternatives :: ([Warning]) }
{-# INLINABLE wrap_Alternatives #-}
wrap_Alternatives :: T_Alternatives  -> Inh_Alternatives  -> (Syn_Alternatives )
wrap_Alternatives (T_Alternatives act) (Inh_Alternatives _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Alternatives_vIn4 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_Alternatives_vOut4 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars) <- return (inv_Alternatives_s5 sem arg)
        return (Syn_Alternatives _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars)
   )

-- cata
{-# NOINLINE sem_Alternatives #-}
sem_Alternatives :: Alternatives  -> T_Alternatives 
sem_Alternatives list = Prelude.foldr sem_Alternatives_Cons sem_Alternatives_Nil (Prelude.map sem_Alternative list)

-- semantic domain
newtype T_Alternatives  = T_Alternatives {
                                         attach_T_Alternatives :: Identity (T_Alternatives_s5 )
                                         }
newtype T_Alternatives_s5  = C_Alternatives_s5 {
                                               inv_Alternatives_s5 :: (T_Alternatives_v4 )
                                               }
data T_Alternatives_s6  = C_Alternatives_s6
type T_Alternatives_v4  = (T_Alternatives_vIn4 ) -> (T_Alternatives_vOut4 )
data T_Alternatives_vIn4  = T_Alternatives_vIn4 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_Alternatives_vOut4  = T_Alternatives_vOut4 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) ([([PatternElement], Bool)]) (InfoTrees) (IO ()) ([Warning]) (Alternatives) (Names) (Int) ([Warning])
{-# NOINLINE sem_Alternatives_Cons #-}
sem_Alternatives_Cons :: T_Alternative  -> T_Alternatives  -> T_Alternatives 
sem_Alternatives_Cons arg_hd_ arg_tl_ = T_Alternatives (return st5) where
   {-# NOINLINE st5 #-}
   st5 = let
      v4 :: T_Alternatives_v4 
      v4 = \ (T_Alternatives_vIn4 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _hdX2 = Control.Monad.Identity.runIdentity (attach_T_Alternative (arg_hd_))
         _tlX5 = Control.Monad.Identity.runIdentity (attach_T_Alternatives (arg_tl_))
         (T_Alternative_vOut1 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIelements _hdIinfoTrees _hdImatchIO _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIunrwar) = inv_Alternative_s2 _hdX2 (T_Alternative_vIn1 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaLeft _hdObetaRight _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk)
         (T_Alternatives_vOut4 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIelementss _tlIinfoTrees _tlImatchIO _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIunrwars) = inv_Alternatives_s5 _tlX5 (T_Alternatives_vIn4 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaLeft _tlObetaRight _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule125 _hdIassumptions _tlIassumptions
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule126 _hdIconstraints _tlIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule127 _hdIinfoTrees _tlIinfoTrees
         _lhsOelementss :: [([PatternElement], Bool)]
         _lhsOelementss = rule128 _hdIelements _tlIelementss
         _lhsOunrwars :: [Warning]
         _lhsOunrwars = rule129 _hdIunrwar _tlIunrwars
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule130 _hdIcollectInstances _tlIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule131 _hdIunboundNames _tlIunboundNames
         _self = rule132 _hdIself _tlIself
         _lhsOself :: Alternatives
         _lhsOself = rule133 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule134 _tlIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule135 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule136 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule137 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule138 _tlIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule139 _tlImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule140 _tlIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule141 _tlIuniqueChunk
         _hdOallPatterns = rule142 _lhsIallPatterns
         _hdOallTypeSchemes = rule143 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule144 _lhsIavailablePredicates
         _hdObetaLeft = rule145 _lhsIbetaLeft
         _hdObetaRight = rule146 _lhsIbetaRight
         _hdObetaUnique = rule147 _lhsIbetaUnique
         _hdOclassEnvironment = rule148 _lhsIclassEnvironment
         _hdOcollectErrors = rule149 _lhsIcollectErrors
         _hdOcollectWarnings = rule150 _lhsIcollectWarnings
         _hdOcounter = rule151 _lhsIcounter
         _hdOcurrentChunk = rule152 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule153 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule154 _lhsIimportEnvironment
         _hdOmatchIO = rule155 _lhsImatchIO
         _hdOmonos = rule156 _lhsImonos
         _hdOnamesInScope = rule157 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule158 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule159 _lhsIparentTree
         _hdOpatternMatchWarnings = rule160 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule161 _lhsIsubstitution
         _hdOtypeschemeMap = rule162 _lhsItypeschemeMap
         _hdOuniqueChunk = rule163 _lhsIuniqueChunk
         _tlOallPatterns = rule164 _lhsIallPatterns
         _tlOallTypeSchemes = rule165 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule166 _lhsIavailablePredicates
         _tlObetaLeft = rule167 _lhsIbetaLeft
         _tlObetaRight = rule168 _lhsIbetaRight
         _tlObetaUnique = rule169 _hdIbetaUnique
         _tlOclassEnvironment = rule170 _lhsIclassEnvironment
         _tlOcollectErrors = rule171 _hdIcollectErrors
         _tlOcollectWarnings = rule172 _hdIcollectWarnings
         _tlOcounter = rule173 _hdIcounter
         _tlOcurrentChunk = rule174 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule175 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule176 _lhsIimportEnvironment
         _tlOmatchIO = rule177 _hdImatchIO
         _tlOmonos = rule178 _lhsImonos
         _tlOnamesInScope = rule179 _lhsInamesInScope
         _tlOorderedTypeSynonyms = rule180 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule181 _lhsIparentTree
         _tlOpatternMatchWarnings = rule182 _hdIpatternMatchWarnings
         _tlOsubstitution = rule183 _lhsIsubstitution
         _tlOtypeschemeMap = rule184 _lhsItypeschemeMap
         _tlOuniqueChunk = rule185 _hdIuniqueChunk
         __result_ = T_Alternatives_vOut4 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
         in __result_ )
     in C_Alternatives_s5 v4
   {-# INLINE rule125 #-}
   rule125 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
                                _hdIassumptions `combine` _tlIassumptions
   {-# INLINE rule126 #-}
   rule126 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
                                _hdIconstraints : _tlIconstraintslist
   {-# INLINE rule127 #-}
   rule127 = \ ((_hdIinfoTrees) :: InfoTrees) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTrees ++ _tlIinfoTrees
   {-# INLINE rule128 #-}
   rule128 = \ ((_hdIelements) ::  ([PatternElement], Bool) ) ((_tlIelementss) :: [([PatternElement], Bool)]) ->
                                         _hdIelements : _tlIelementss
   {-# INLINE rule129 #-}
   rule129 = \ ((_hdIunrwar) :: Warning) ((_tlIunrwars) :: [Warning]) ->
                                         _hdIunrwar   : _tlIunrwars
   {-# INLINE rule130 #-}
   rule130 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule131 #-}
   rule131 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule132 #-}
   rule132 = \ ((_hdIself) :: Alternative) ((_tlIself) :: Alternatives) ->
     (:) _hdIself _tlIself
   {-# INLINE rule133 #-}
   rule133 = \ _self ->
     _self
   {-# INLINE rule134 #-}
   rule134 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule135 #-}
   rule135 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule136 #-}
   rule136 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule137 #-}
   rule137 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule138 #-}
   rule138 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule139 #-}
   rule139 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule140 #-}
   rule140 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule141 #-}
   rule141 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule142 #-}
   rule142 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule143 #-}
   rule143 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule144 #-}
   rule144 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule145 #-}
   rule145 = \ ((_lhsIbetaLeft) :: Tp) ->
     _lhsIbetaLeft
   {-# INLINE rule146 #-}
   rule146 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule147 #-}
   rule147 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule148 #-}
   rule148 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule149 #-}
   rule149 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule150 #-}
   rule150 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule151 #-}
   rule151 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule152 #-}
   rule152 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule153 #-}
   rule153 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule154 #-}
   rule154 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule155 #-}
   rule155 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule156 #-}
   rule156 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule157 #-}
   rule157 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule158 #-}
   rule158 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule159 #-}
   rule159 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule160 #-}
   rule160 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule161 #-}
   rule161 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule162 #-}
   rule162 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule163 #-}
   rule163 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule164 #-}
   rule164 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule165 #-}
   rule165 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule166 #-}
   rule166 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule167 #-}
   rule167 = \ ((_lhsIbetaLeft) :: Tp) ->
     _lhsIbetaLeft
   {-# INLINE rule168 #-}
   rule168 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule169 #-}
   rule169 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule170 #-}
   rule170 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule171 #-}
   rule171 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule172 #-}
   rule172 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule173 #-}
   rule173 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule174 #-}
   rule174 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule175 #-}
   rule175 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule176 #-}
   rule176 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule177 #-}
   rule177 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule178 #-}
   rule178 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule179 #-}
   rule179 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule180 #-}
   rule180 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule181 #-}
   rule181 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule182 #-}
   rule182 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule183 #-}
   rule183 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule184 #-}
   rule184 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule185 #-}
   rule185 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
{-# NOINLINE sem_Alternatives_Nil #-}
sem_Alternatives_Nil ::  T_Alternatives 
sem_Alternatives_Nil  = T_Alternatives (return st5) where
   {-# NOINLINE st5 #-}
   st5 = let
      v4 :: T_Alternatives_v4 
      v4 = \ (T_Alternatives_vIn4 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaLeft _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule186  ()
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule187  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule188  ()
         _lhsOelementss :: [([PatternElement], Bool)]
         _lhsOelementss = rule189  ()
         _lhsOunrwars :: [Warning]
         _lhsOunrwars = rule190  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule191  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule192  ()
         _self = rule193  ()
         _lhsOself :: Alternatives
         _lhsOself = rule194 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule195 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule196 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule197 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule198 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule199 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule200 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule201 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule202 _lhsIuniqueChunk
         __result_ = T_Alternatives_vOut4 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
         in __result_ )
     in C_Alternatives_s5 v4
   {-# INLINE rule186 #-}
   rule186 = \  (_ :: ()) ->
                                noAssumptions
   {-# INLINE rule187 #-}
   rule187 = \  (_ :: ()) ->
                                []
   {-# INLINE rule188 #-}
   rule188 = \  (_ :: ()) ->
                               []
   {-# INLINE rule189 #-}
   rule189 = \  (_ :: ()) ->
                                         []
   {-# INLINE rule190 #-}
   rule190 = \  (_ :: ()) ->
                                         []
   {-# INLINE rule191 #-}
   rule191 = \  (_ :: ()) ->
     []
   {-# INLINE rule192 #-}
   rule192 = \  (_ :: ()) ->
     []
   {-# INLINE rule193 #-}
   rule193 = \  (_ :: ()) ->
     []
   {-# INLINE rule194 #-}
   rule194 = \ _self ->
     _self
   {-# INLINE rule195 #-}
   rule195 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule196 #-}
   rule196 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule197 #-}
   rule197 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule198 #-}
   rule198 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule199 #-}
   rule199 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule200 #-}
   rule200 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule201 #-}
   rule201 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule202 #-}
   rule202 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- AnnotatedType -----------------------------------------------
-- wrapper
data Inh_AnnotatedType  = Inh_AnnotatedType { counter_Inh_AnnotatedType :: (Int), namesInScope_Inh_AnnotatedType :: (Names) }
data Syn_AnnotatedType  = Syn_AnnotatedType { counter_Syn_AnnotatedType :: (Int), self_Syn_AnnotatedType :: (AnnotatedType), unboundNames_Syn_AnnotatedType :: (Names) }
{-# INLINABLE wrap_AnnotatedType #-}
wrap_AnnotatedType :: T_AnnotatedType  -> Inh_AnnotatedType  -> (Syn_AnnotatedType )
wrap_AnnotatedType (T_AnnotatedType act) (Inh_AnnotatedType _lhsIcounter _lhsInamesInScope) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_AnnotatedType_vIn7 _lhsIcounter _lhsInamesInScope
        (T_AnnotatedType_vOut7 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_AnnotatedType_s8 sem arg)
        return (Syn_AnnotatedType _lhsOcounter _lhsOself _lhsOunboundNames)
   )

-- cata
{-# INLINE sem_AnnotatedType #-}
sem_AnnotatedType :: AnnotatedType  -> T_AnnotatedType 
sem_AnnotatedType ( AnnotatedType_AnnotatedType range_ strict_ type_ ) = sem_AnnotatedType_AnnotatedType ( sem_Range range_ ) strict_ ( sem_Type type_ )

-- semantic domain
newtype T_AnnotatedType  = T_AnnotatedType {
                                           attach_T_AnnotatedType :: Identity (T_AnnotatedType_s8 )
                                           }
newtype T_AnnotatedType_s8  = C_AnnotatedType_s8 {
                                                 inv_AnnotatedType_s8 :: (T_AnnotatedType_v7 )
                                                 }
data T_AnnotatedType_s9  = C_AnnotatedType_s9
type T_AnnotatedType_v7  = (T_AnnotatedType_vIn7 ) -> (T_AnnotatedType_vOut7 )
data T_AnnotatedType_vIn7  = T_AnnotatedType_vIn7 (Int) (Names)
data T_AnnotatedType_vOut7  = T_AnnotatedType_vOut7 (Int) (AnnotatedType) (Names)
{-# NOINLINE sem_AnnotatedType_AnnotatedType #-}
sem_AnnotatedType_AnnotatedType :: T_Range  -> (Bool) -> T_Type  -> T_AnnotatedType 
sem_AnnotatedType_AnnotatedType arg_range_ arg_strict_ arg_type_ = T_AnnotatedType (return st8) where
   {-# NOINLINE st8 #-}
   st8 = let
      v7 :: T_AnnotatedType_v7 
      v7 = \ (T_AnnotatedType_vIn7 _lhsIcounter _lhsInamesInScope) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule203  ()
         _self = rule204 _rangeIself _typeIself arg_strict_
         _lhsOself :: AnnotatedType
         _lhsOself = rule205 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule206 _lhsIcounter
         __result_ = T_AnnotatedType_vOut7 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_AnnotatedType_s8 v7
   {-# INLINE rule203 #-}
   rule203 = \  (_ :: ()) ->
     []
   {-# INLINE rule204 #-}
   rule204 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) strict_ ->
     AnnotatedType_AnnotatedType _rangeIself strict_ _typeIself
   {-# INLINE rule205 #-}
   rule205 = \ _self ->
     _self
   {-# INLINE rule206 #-}
   rule206 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter

-- AnnotatedTypes ----------------------------------------------
-- wrapper
data Inh_AnnotatedTypes  = Inh_AnnotatedTypes { counter_Inh_AnnotatedTypes :: (Int), namesInScope_Inh_AnnotatedTypes :: (Names) }
data Syn_AnnotatedTypes  = Syn_AnnotatedTypes { counter_Syn_AnnotatedTypes :: (Int), self_Syn_AnnotatedTypes :: (AnnotatedTypes), unboundNames_Syn_AnnotatedTypes :: (Names) }
{-# INLINABLE wrap_AnnotatedTypes #-}
wrap_AnnotatedTypes :: T_AnnotatedTypes  -> Inh_AnnotatedTypes  -> (Syn_AnnotatedTypes )
wrap_AnnotatedTypes (T_AnnotatedTypes act) (Inh_AnnotatedTypes _lhsIcounter _lhsInamesInScope) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_AnnotatedTypes_vIn10 _lhsIcounter _lhsInamesInScope
        (T_AnnotatedTypes_vOut10 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_AnnotatedTypes_s11 sem arg)
        return (Syn_AnnotatedTypes _lhsOcounter _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_AnnotatedTypes #-}
sem_AnnotatedTypes :: AnnotatedTypes  -> T_AnnotatedTypes 
sem_AnnotatedTypes list = Prelude.foldr sem_AnnotatedTypes_Cons sem_AnnotatedTypes_Nil (Prelude.map sem_AnnotatedType list)

-- semantic domain
newtype T_AnnotatedTypes  = T_AnnotatedTypes {
                                             attach_T_AnnotatedTypes :: Identity (T_AnnotatedTypes_s11 )
                                             }
newtype T_AnnotatedTypes_s11  = C_AnnotatedTypes_s11 {
                                                     inv_AnnotatedTypes_s11 :: (T_AnnotatedTypes_v10 )
                                                     }
data T_AnnotatedTypes_s12  = C_AnnotatedTypes_s12
type T_AnnotatedTypes_v10  = (T_AnnotatedTypes_vIn10 ) -> (T_AnnotatedTypes_vOut10 )
data T_AnnotatedTypes_vIn10  = T_AnnotatedTypes_vIn10 (Int) (Names)
data T_AnnotatedTypes_vOut10  = T_AnnotatedTypes_vOut10 (Int) (AnnotatedTypes) (Names)
{-# NOINLINE sem_AnnotatedTypes_Cons #-}
sem_AnnotatedTypes_Cons :: T_AnnotatedType  -> T_AnnotatedTypes  -> T_AnnotatedTypes 
sem_AnnotatedTypes_Cons arg_hd_ arg_tl_ = T_AnnotatedTypes (return st11) where
   {-# NOINLINE st11 #-}
   st11 = let
      v10 :: T_AnnotatedTypes_v10 
      v10 = \ (T_AnnotatedTypes_vIn10 _lhsIcounter _lhsInamesInScope) -> ( let
         _hdX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_hd_))
         _tlX11 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedTypes (arg_tl_))
         (T_AnnotatedType_vOut7 _hdIcounter _hdIself _hdIunboundNames) = inv_AnnotatedType_s8 _hdX8 (T_AnnotatedType_vIn7 _hdOcounter _hdOnamesInScope)
         (T_AnnotatedTypes_vOut10 _tlIcounter _tlIself _tlIunboundNames) = inv_AnnotatedTypes_s11 _tlX11 (T_AnnotatedTypes_vIn10 _tlOcounter _tlOnamesInScope)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule207 _hdIunboundNames _tlIunboundNames
         _self = rule208 _hdIself _tlIself
         _lhsOself :: AnnotatedTypes
         _lhsOself = rule209 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule210 _tlIcounter
         _hdOcounter = rule211 _lhsIcounter
         _hdOnamesInScope = rule212 _lhsInamesInScope
         _tlOcounter = rule213 _hdIcounter
         _tlOnamesInScope = rule214 _lhsInamesInScope
         __result_ = T_AnnotatedTypes_vOut10 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_AnnotatedTypes_s11 v10
   {-# INLINE rule207 #-}
   rule207 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule208 #-}
   rule208 = \ ((_hdIself) :: AnnotatedType) ((_tlIself) :: AnnotatedTypes) ->
     (:) _hdIself _tlIself
   {-# INLINE rule209 #-}
   rule209 = \ _self ->
     _self
   {-# INLINE rule210 #-}
   rule210 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule211 #-}
   rule211 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule212 #-}
   rule212 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule213 #-}
   rule213 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule214 #-}
   rule214 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_AnnotatedTypes_Nil #-}
sem_AnnotatedTypes_Nil ::  T_AnnotatedTypes 
sem_AnnotatedTypes_Nil  = T_AnnotatedTypes (return st11) where
   {-# NOINLINE st11 #-}
   st11 = let
      v10 :: T_AnnotatedTypes_v10 
      v10 = \ (T_AnnotatedTypes_vIn10 _lhsIcounter _lhsInamesInScope) -> ( let
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule215  ()
         _self = rule216  ()
         _lhsOself :: AnnotatedTypes
         _lhsOself = rule217 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule218 _lhsIcounter
         __result_ = T_AnnotatedTypes_vOut10 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_AnnotatedTypes_s11 v10
   {-# INLINE rule215 #-}
   rule215 = \  (_ :: ()) ->
     []
   {-# INLINE rule216 #-}
   rule216 = \  (_ :: ()) ->
     []
   {-# INLINE rule217 #-}
   rule217 = \ _self ->
     _self
   {-# INLINE rule218 #-}
   rule218 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter

-- Body --------------------------------------------------------
-- wrapper
data Inh_Body  = Inh_Body { allPatterns_Inh_Body :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Body :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Body :: (Predicates), betaUnique_Inh_Body :: (Int), classEnvironment_Inh_Body :: (ClassEnvironment), collectErrors_Inh_Body :: (TypeErrors), collectWarnings_Inh_Body :: (Warnings), counter_Inh_Body :: (Int), currentChunk_Inh_Body :: (Int), dictionaryEnvironment_Inh_Body :: (DictionaryEnvironment), importEnvironment_Inh_Body :: (ImportEnvironment), matchIO_Inh_Body :: (IO ()), monos_Inh_Body :: (Monos), namesInScope_Inh_Body :: (Names), orderedTypeSynonyms_Inh_Body :: (OrderedTypeSynonyms), patternMatchWarnings_Inh_Body :: ([Warning]), substitution_Inh_Body :: (FixpointSubstitution), typeschemeMap_Inh_Body :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Body :: (Int) }
data Syn_Body  = Syn_Body { assumptions_Syn_Body :: (Assumptions), betaUnique_Syn_Body :: (Int), collectErrors_Syn_Body :: (TypeErrors), collectInstances_Syn_Body :: ([(Name, Instance)]), collectWarnings_Syn_Body :: (Warnings), constraints_Syn_Body :: (ConstraintSet), counter_Syn_Body :: (Int), declVarNames_Syn_Body :: (Names), dictionaryEnvironment_Syn_Body :: (DictionaryEnvironment), infoTree_Syn_Body :: (InfoTree), matchIO_Syn_Body :: (IO ()), patternMatchWarnings_Syn_Body :: ([Warning]), self_Syn_Body :: (Body), toplevelTypes_Syn_Body :: (TypeEnvironment), unboundNames_Syn_Body :: (Names), uniqueChunk_Syn_Body :: (Int) }
{-# INLINABLE wrap_Body #-}
wrap_Body :: T_Body  -> Inh_Body  -> (Syn_Body )
wrap_Body (T_Body act) (Inh_Body _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Body_vIn13 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_Body_vOut13 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_Body_s14 sem arg)
        return (Syn_Body _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_Body #-}
sem_Body :: Body  -> T_Body 
sem_Body ( Body_Hole range_ id_ ) = sem_Body_Hole ( sem_Range range_ ) id_
sem_Body ( Body_Body range_ importdeclarations_ declarations_ ) = sem_Body_Body ( sem_Range range_ ) ( sem_ImportDeclarations importdeclarations_ ) ( sem_Declarations declarations_ )

-- semantic domain
newtype T_Body  = T_Body {
                         attach_T_Body :: Identity (T_Body_s14 )
                         }
newtype T_Body_s14  = C_Body_s14 {
                                 inv_Body_s14 :: (T_Body_v13 )
                                 }
data T_Body_s15  = C_Body_s15
type T_Body_v13  = (T_Body_vIn13 ) -> (T_Body_vOut13 )
data T_Body_vIn13  = T_Body_vIn13 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_Body_vOut13  = T_Body_vOut13 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (Names) (DictionaryEnvironment) (InfoTree) (IO ()) ([Warning]) (Body) (TypeEnvironment) (Names) (Int)
{-# NOINLINE sem_Body_Hole #-}
sem_Body_Hole :: T_Range  -> (Integer) -> T_Body 
sem_Body_Hole arg_range_ arg_id_ = T_Body (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_Body_v13 
      v13 = \ (T_Body_vIn13 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule219  ()
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule220  ()
         _lhsOtoplevelTypes :: TypeEnvironment
         _lhsOtoplevelTypes = rule221  ()
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule222  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule223  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule224  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule225  ()
         _self = rule226 _rangeIself arg_id_
         _lhsOself :: Body
         _lhsOself = rule227 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule228 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule229 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule230 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule231 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule232 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule233 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule234 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule235 _lhsIuniqueChunk
         __result_ = T_Body_vOut13 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Body_s14 v13
   {-# INLINE rule219 #-}
   rule219 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule220 #-}
   rule220 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule221 #-}
   rule221 = \  (_ :: ()) ->
                                   M.empty
   {-# INLINE rule222 #-}
   rule222 = \  (_ :: ()) ->
                                    root (LocalInfo {self = UHA_Decls [], assignedType = Nothing, monos = []}) []
   {-# INLINE rule223 #-}
   rule223 = \  (_ :: ()) ->
     []
   {-# INLINE rule224 #-}
   rule224 = \  (_ :: ()) ->
     []
   {-# INLINE rule225 #-}
   rule225 = \  (_ :: ()) ->
     []
   {-# INLINE rule226 #-}
   rule226 = \ ((_rangeIself) :: Range) id_ ->
     Body_Hole _rangeIself id_
   {-# INLINE rule227 #-}
   rule227 = \ _self ->
     _self
   {-# INLINE rule228 #-}
   rule228 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule229 #-}
   rule229 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule230 #-}
   rule230 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule231 #-}
   rule231 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule232 #-}
   rule232 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule233 #-}
   rule233 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule234 #-}
   rule234 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule235 #-}
   rule235 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Body_Body #-}
sem_Body_Body :: T_Range  -> T_ImportDeclarations  -> T_Declarations  -> T_Body 
sem_Body_Body arg_range_ arg_importdeclarations_ arg_declarations_ = T_Body (return st14) where
   {-# NOINLINE st14 #-}
   st14 = let
      v13 :: T_Body_v13 
      v13 = \ (T_Body_vIn13 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _importdeclarationsX74 = Control.Monad.Identity.runIdentity (attach_T_ImportDeclarations (arg_importdeclarations_))
         _declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_ImportDeclarations_vOut73 _importdeclarationsIself) = inv_ImportDeclarations_s74 _importdeclarationsX74 (T_ImportDeclarations_vIn73 )
         (T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
         _declarationsObindingGroups = rule236  ()
         _lhsOassumptions :: Assumptions
         (_csetBinds,_lhsOassumptions) = rule237 _aset _cinfo _lhsIimportEnvironment
         _constraints = rule238 _cset _csetBinds
         _lhsObetaUnique :: Int
         (_aset,_cset,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule239 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIcurrentChunk _lhsImonos
         _inferredTypes = rule240 _implicitsFM _lhsItypeschemeMap
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule241 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule242 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
         _lhsOtoplevelTypes :: TypeEnvironment
         _lhsOtoplevelTypes = rule243 _declarationsItypeSignatures _inferredTypes
         _allTypeSchemes = rule244 _lhsIallTypeSchemes _localTypes
         _localTypes = rule245 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
         _declarationsOtypeSignatures = rule246  ()
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule247 _chunkNr
         _cinfo = rule248  ()
         _declInfo = rule249 _declarationsIself _lhsImonos
         _parentTree = rule250 _declInfo _declarationsIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule251 _parentTree
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule252 _declarationsIcollectInstances
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule253 _declarationsIdeclVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule254 _declarationsIunboundNames
         _self = rule255 _declarationsIself _importdeclarationsIself _rangeIself
         _lhsOself :: Body
         _lhsOself = rule256 _self
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule257 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule258 _declarationsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule259 _declarationsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule260 _declarationsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule261 _declarationsIpatternMatchWarnings
         _declarationsOallPatterns = rule262 _lhsIallPatterns
         _declarationsOallTypeSchemes = rule263 _allTypeSchemes
         _declarationsOavailablePredicates = rule264 _lhsIavailablePredicates
         _declarationsObetaUnique = rule265 _lhsIbetaUnique
         _declarationsOclassEnvironment = rule266 _lhsIclassEnvironment
         _declarationsOcollectErrors = rule267 _lhsIcollectErrors
         _declarationsOcollectWarnings = rule268 _lhsIcollectWarnings
         _declarationsOcounter = rule269 _lhsIcounter
         _declarationsOcurrentChunk = rule270 _lhsIcurrentChunk
         _declarationsOdictionaryEnvironment = rule271 _lhsIdictionaryEnvironment
         _declarationsOimportEnvironment = rule272 _lhsIimportEnvironment
         _declarationsOinheritedBDG = rule273 _inheritedBDG
         _declarationsOmatchIO = rule274 _lhsImatchIO
         _declarationsOmonos = rule275 _lhsImonos
         _declarationsOnamesInScope = rule276 _lhsInamesInScope
         _declarationsOorderedTypeSynonyms = rule277 _lhsIorderedTypeSynonyms
         _declarationsOparentTree = rule278 _parentTree
         _declarationsOpatternMatchWarnings = rule279 _lhsIpatternMatchWarnings
         _declarationsOsubstitution = rule280 _lhsIsubstitution
         _declarationsOtypeschemeMap = rule281 _lhsItypeschemeMap
         _declarationsOuniqueChunk = rule282 _lhsIuniqueChunk
         __result_ = T_Body_vOut13 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOtoplevelTypes _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Body_s14 v13
   {-# INLINE rule236 #-}
   rule236 = \  (_ :: ()) ->
                                          []
   {-# INLINE rule237 #-}
   rule237 = \ _aset _cinfo ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                          (typeEnvironment _lhsIimportEnvironment .:::. _aset) _cinfo
   {-# INLINE rule238 #-}
   rule238 = \ _cset _csetBinds ->
                                          _csetBinds .>>. _cset
   {-# INLINE rule239 #-}
   rule239 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
           let inputBDG = (True, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, Nothing, _declarationsIbetaUnique)
           in performBindingGroup inputBDG _declarationsIbindingGroups
   {-# INLINE rule240 #-}
   rule240 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
                                        findInferredTypes _lhsItypeschemeMap _implicitsFM
   {-# INLINE rule241 #-}
   rule241 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
                                        missingTypeSignature True _declarationsIsimplePatNames _inferredTypes
                                        ++ _declarationsIcollectWarnings
   {-# INLINE rule242 #-}
   rule242 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
                                        restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
                                        ++ _declarationsIcollectErrors
   {-# INLINE rule243 #-}
   rule243 = \ ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
                                   _declarationsItypeSignatures `M.union` _inferredTypes
   {-# INLINE rule244 #-}
   rule244 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
                                    _localTypes `M.union` _lhsIallTypeSchemes
   {-# INLINE rule245 #-}
   rule245 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
                                    makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
   {-# INLINE rule246 #-}
   rule246 = \  (_ :: ()) ->
                                                                  M.empty
   {-# INLINE rule247 #-}
   rule247 = \ _chunkNr ->
                                                     _chunkNr
   {-# INLINE rule248 #-}
   rule248 = \  (_ :: ()) ->
     \name -> variableConstraint "variable" (nameToUHA_Expr name)
        [ FolkloreConstraint, HasTrustFactor 10.0, IsImported name ]
   {-# INLINE rule249 #-}
   rule249 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
                          LocalInfo { self = UHA_Decls _declarationsIself
                                    , assignedType = Nothing
                                    , monos = _lhsImonos
                                    }
   {-# INLINE rule250 #-}
   rule250 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) ->
                                      root _declInfo _declarationsIinfoTrees
   {-# INLINE rule251 #-}
   rule251 = \ _parentTree ->
                                      _parentTree
   {-# INLINE rule252 #-}
   rule252 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
     _declarationsIcollectInstances
   {-# INLINE rule253 #-}
   rule253 = \ ((_declarationsIdeclVarNames) :: Names) ->
     _declarationsIdeclVarNames
   {-# INLINE rule254 #-}
   rule254 = \ ((_declarationsIunboundNames) :: Names) ->
     _declarationsIunboundNames
   {-# INLINE rule255 #-}
   rule255 = \ ((_declarationsIself) :: Declarations) ((_importdeclarationsIself) :: ImportDeclarations) ((_rangeIself) :: Range) ->
     Body_Body _rangeIself _importdeclarationsIself _declarationsIself
   {-# INLINE rule256 #-}
   rule256 = \ _self ->
     _self
   {-# INLINE rule257 #-}
   rule257 = \ _constraints ->
     _constraints
   {-# INLINE rule258 #-}
   rule258 = \ ((_declarationsIcounter) :: Int) ->
     _declarationsIcounter
   {-# INLINE rule259 #-}
   rule259 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _declarationsIdictionaryEnvironment
   {-# INLINE rule260 #-}
   rule260 = \ ((_declarationsImatchIO) :: IO ()) ->
     _declarationsImatchIO
   {-# INLINE rule261 #-}
   rule261 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
     _declarationsIpatternMatchWarnings
   {-# INLINE rule262 #-}
   rule262 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule263 #-}
   rule263 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule264 #-}
   rule264 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule265 #-}
   rule265 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule266 #-}
   rule266 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule267 #-}
   rule267 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule268 #-}
   rule268 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule269 #-}
   rule269 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule270 #-}
   rule270 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule271 #-}
   rule271 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule272 #-}
   rule272 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule273 #-}
   rule273 = \ _inheritedBDG ->
     _inheritedBDG
   {-# INLINE rule274 #-}
   rule274 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule275 #-}
   rule275 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule276 #-}
   rule276 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule277 #-}
   rule277 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule278 #-}
   rule278 = \ _parentTree ->
     _parentTree
   {-# INLINE rule279 #-}
   rule279 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule280 #-}
   rule280 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule281 #-}
   rule281 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule282 #-}
   rule282 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- Constructor -------------------------------------------------
-- wrapper
data Inh_Constructor  = Inh_Constructor { counter_Inh_Constructor :: (Int), namesInScope_Inh_Constructor :: (Names) }
data Syn_Constructor  = Syn_Constructor { counter_Syn_Constructor :: (Int), self_Syn_Constructor :: (Constructor), unboundNames_Syn_Constructor :: (Names) }
{-# INLINABLE wrap_Constructor #-}
wrap_Constructor :: T_Constructor  -> Inh_Constructor  -> (Syn_Constructor )
wrap_Constructor (T_Constructor act) (Inh_Constructor _lhsIcounter _lhsInamesInScope) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope
        (T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_Constructor_s17 sem arg)
        return (Syn_Constructor _lhsOcounter _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_Constructor #-}
sem_Constructor :: Constructor  -> T_Constructor 
sem_Constructor ( Constructor_Constructor range_ constructor_ types_ ) = sem_Constructor_Constructor ( sem_Range range_ ) ( sem_Name constructor_ ) ( sem_AnnotatedTypes types_ )
sem_Constructor ( Constructor_Infix range_ leftType_ constructorOperator_ rightType_ ) = sem_Constructor_Infix ( sem_Range range_ ) ( sem_AnnotatedType leftType_ ) ( sem_Name constructorOperator_ ) ( sem_AnnotatedType rightType_ )
sem_Constructor ( Constructor_Record range_ constructor_ fieldDeclarations_ ) = sem_Constructor_Record ( sem_Range range_ ) ( sem_Name constructor_ ) ( sem_FieldDeclarations fieldDeclarations_ )

-- semantic domain
newtype T_Constructor  = T_Constructor {
                                       attach_T_Constructor :: Identity (T_Constructor_s17 )
                                       }
newtype T_Constructor_s17  = C_Constructor_s17 {
                                               inv_Constructor_s17 :: (T_Constructor_v16 )
                                               }
data T_Constructor_s18  = C_Constructor_s18
type T_Constructor_v16  = (T_Constructor_vIn16 ) -> (T_Constructor_vOut16 )
data T_Constructor_vIn16  = T_Constructor_vIn16 (Int) (Names)
data T_Constructor_vOut16  = T_Constructor_vOut16 (Int) (Constructor) (Names)
{-# NOINLINE sem_Constructor_Constructor #-}
sem_Constructor_Constructor :: T_Range  -> T_Name  -> T_AnnotatedTypes  -> T_Constructor 
sem_Constructor_Constructor arg_range_ arg_constructor_ arg_types_ = T_Constructor (return st17) where
   {-# NOINLINE st17 #-}
   st17 = let
      v16 :: T_Constructor_v16 
      v16 = \ (T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _constructorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructor_))
         _typesX11 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedTypes (arg_types_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _constructorIself) = inv_Name_s113 _constructorX113 (T_Name_vIn112 )
         (T_AnnotatedTypes_vOut10 _typesIcounter _typesIself _typesIunboundNames) = inv_AnnotatedTypes_s11 _typesX11 (T_AnnotatedTypes_vIn10 _typesOcounter _typesOnamesInScope)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule283 _typesIunboundNames
         _self = rule284 _constructorIself _rangeIself _typesIself
         _lhsOself :: Constructor
         _lhsOself = rule285 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule286 _typesIcounter
         _typesOcounter = rule287 _lhsIcounter
         _typesOnamesInScope = rule288 _lhsInamesInScope
         __result_ = T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Constructor_s17 v16
   {-# INLINE rule283 #-}
   rule283 = \ ((_typesIunboundNames) :: Names) ->
     _typesIunboundNames
   {-# INLINE rule284 #-}
   rule284 = \ ((_constructorIself) :: Name) ((_rangeIself) :: Range) ((_typesIself) :: AnnotatedTypes) ->
     Constructor_Constructor _rangeIself _constructorIself _typesIself
   {-# INLINE rule285 #-}
   rule285 = \ _self ->
     _self
   {-# INLINE rule286 #-}
   rule286 = \ ((_typesIcounter) :: Int) ->
     _typesIcounter
   {-# INLINE rule287 #-}
   rule287 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule288 #-}
   rule288 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_Constructor_Infix #-}
sem_Constructor_Infix :: T_Range  -> T_AnnotatedType  -> T_Name  -> T_AnnotatedType  -> T_Constructor 
sem_Constructor_Infix arg_range_ arg_leftType_ arg_constructorOperator_ arg_rightType_ = T_Constructor (return st17) where
   {-# NOINLINE st17 #-}
   st17 = let
      v16 :: T_Constructor_v16 
      v16 = \ (T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _leftTypeX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_leftType_))
         _constructorOperatorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructorOperator_))
         _rightTypeX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_rightType_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_AnnotatedType_vOut7 _leftTypeIcounter _leftTypeIself _leftTypeIunboundNames) = inv_AnnotatedType_s8 _leftTypeX8 (T_AnnotatedType_vIn7 _leftTypeOcounter _leftTypeOnamesInScope)
         (T_Name_vOut112 _constructorOperatorIself) = inv_Name_s113 _constructorOperatorX113 (T_Name_vIn112 )
         (T_AnnotatedType_vOut7 _rightTypeIcounter _rightTypeIself _rightTypeIunboundNames) = inv_AnnotatedType_s8 _rightTypeX8 (T_AnnotatedType_vIn7 _rightTypeOcounter _rightTypeOnamesInScope)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule289 _leftTypeIunboundNames _rightTypeIunboundNames
         _self = rule290 _constructorOperatorIself _leftTypeIself _rangeIself _rightTypeIself
         _lhsOself :: Constructor
         _lhsOself = rule291 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule292 _rightTypeIcounter
         _leftTypeOcounter = rule293 _lhsIcounter
         _leftTypeOnamesInScope = rule294 _lhsInamesInScope
         _rightTypeOcounter = rule295 _leftTypeIcounter
         _rightTypeOnamesInScope = rule296 _lhsInamesInScope
         __result_ = T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Constructor_s17 v16
   {-# INLINE rule289 #-}
   rule289 = \ ((_leftTypeIunboundNames) :: Names) ((_rightTypeIunboundNames) :: Names) ->
     _leftTypeIunboundNames ++ _rightTypeIunboundNames
   {-# INLINE rule290 #-}
   rule290 = \ ((_constructorOperatorIself) :: Name) ((_leftTypeIself) :: AnnotatedType) ((_rangeIself) :: Range) ((_rightTypeIself) :: AnnotatedType) ->
     Constructor_Infix _rangeIself _leftTypeIself _constructorOperatorIself _rightTypeIself
   {-# INLINE rule291 #-}
   rule291 = \ _self ->
     _self
   {-# INLINE rule292 #-}
   rule292 = \ ((_rightTypeIcounter) :: Int) ->
     _rightTypeIcounter
   {-# INLINE rule293 #-}
   rule293 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule294 #-}
   rule294 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule295 #-}
   rule295 = \ ((_leftTypeIcounter) :: Int) ->
     _leftTypeIcounter
   {-# INLINE rule296 #-}
   rule296 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_Constructor_Record #-}
sem_Constructor_Record :: T_Range  -> T_Name  -> T_FieldDeclarations  -> T_Constructor 
sem_Constructor_Record arg_range_ arg_constructor_ arg_fieldDeclarations_ = T_Constructor (return st17) where
   {-# NOINLINE st17 #-}
   st17 = let
      v16 :: T_Constructor_v16 
      v16 = \ (T_Constructor_vIn16 _lhsIcounter _lhsInamesInScope) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _constructorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructor_))
         _fieldDeclarationsX50 = Control.Monad.Identity.runIdentity (attach_T_FieldDeclarations (arg_fieldDeclarations_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _constructorIself) = inv_Name_s113 _constructorX113 (T_Name_vIn112 )
         (T_FieldDeclarations_vOut49 _fieldDeclarationsIcounter _fieldDeclarationsIself _fieldDeclarationsIunboundNames) = inv_FieldDeclarations_s50 _fieldDeclarationsX50 (T_FieldDeclarations_vIn49 _fieldDeclarationsOcounter _fieldDeclarationsOnamesInScope)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule297 _fieldDeclarationsIunboundNames
         _self = rule298 _constructorIself _fieldDeclarationsIself _rangeIself
         _lhsOself :: Constructor
         _lhsOself = rule299 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule300 _fieldDeclarationsIcounter
         _fieldDeclarationsOcounter = rule301 _lhsIcounter
         _fieldDeclarationsOnamesInScope = rule302 _lhsInamesInScope
         __result_ = T_Constructor_vOut16 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Constructor_s17 v16
   {-# INLINE rule297 #-}
   rule297 = \ ((_fieldDeclarationsIunboundNames) :: Names) ->
     _fieldDeclarationsIunboundNames
   {-# INLINE rule298 #-}
   rule298 = \ ((_constructorIself) :: Name) ((_fieldDeclarationsIself) :: FieldDeclarations) ((_rangeIself) :: Range) ->
     Constructor_Record _rangeIself _constructorIself _fieldDeclarationsIself
   {-# INLINE rule299 #-}
   rule299 = \ _self ->
     _self
   {-# INLINE rule300 #-}
   rule300 = \ ((_fieldDeclarationsIcounter) :: Int) ->
     _fieldDeclarationsIcounter
   {-# INLINE rule301 #-}
   rule301 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule302 #-}
   rule302 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope

-- Constructors ------------------------------------------------
-- wrapper
data Inh_Constructors  = Inh_Constructors { counter_Inh_Constructors :: (Int), namesInScope_Inh_Constructors :: (Names) }
data Syn_Constructors  = Syn_Constructors { counter_Syn_Constructors :: (Int), self_Syn_Constructors :: (Constructors), unboundNames_Syn_Constructors :: (Names) }
{-# INLINABLE wrap_Constructors #-}
wrap_Constructors :: T_Constructors  -> Inh_Constructors  -> (Syn_Constructors )
wrap_Constructors (T_Constructors act) (Inh_Constructors _lhsIcounter _lhsInamesInScope) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Constructors_vIn19 _lhsIcounter _lhsInamesInScope
        (T_Constructors_vOut19 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_Constructors_s20 sem arg)
        return (Syn_Constructors _lhsOcounter _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_Constructors #-}
sem_Constructors :: Constructors  -> T_Constructors 
sem_Constructors list = Prelude.foldr sem_Constructors_Cons sem_Constructors_Nil (Prelude.map sem_Constructor list)

-- semantic domain
newtype T_Constructors  = T_Constructors {
                                         attach_T_Constructors :: Identity (T_Constructors_s20 )
                                         }
newtype T_Constructors_s20  = C_Constructors_s20 {
                                                 inv_Constructors_s20 :: (T_Constructors_v19 )
                                                 }
data T_Constructors_s21  = C_Constructors_s21
type T_Constructors_v19  = (T_Constructors_vIn19 ) -> (T_Constructors_vOut19 )
data T_Constructors_vIn19  = T_Constructors_vIn19 (Int) (Names)
data T_Constructors_vOut19  = T_Constructors_vOut19 (Int) (Constructors) (Names)
{-# NOINLINE sem_Constructors_Cons #-}
sem_Constructors_Cons :: T_Constructor  -> T_Constructors  -> T_Constructors 
sem_Constructors_Cons arg_hd_ arg_tl_ = T_Constructors (return st20) where
   {-# NOINLINE st20 #-}
   st20 = let
      v19 :: T_Constructors_v19 
      v19 = \ (T_Constructors_vIn19 _lhsIcounter _lhsInamesInScope) -> ( let
         _hdX17 = Control.Monad.Identity.runIdentity (attach_T_Constructor (arg_hd_))
         _tlX20 = Control.Monad.Identity.runIdentity (attach_T_Constructors (arg_tl_))
         (T_Constructor_vOut16 _hdIcounter _hdIself _hdIunboundNames) = inv_Constructor_s17 _hdX17 (T_Constructor_vIn16 _hdOcounter _hdOnamesInScope)
         (T_Constructors_vOut19 _tlIcounter _tlIself _tlIunboundNames) = inv_Constructors_s20 _tlX20 (T_Constructors_vIn19 _tlOcounter _tlOnamesInScope)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule303 _hdIunboundNames _tlIunboundNames
         _self = rule304 _hdIself _tlIself
         _lhsOself :: Constructors
         _lhsOself = rule305 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule306 _tlIcounter
         _hdOcounter = rule307 _lhsIcounter
         _hdOnamesInScope = rule308 _lhsInamesInScope
         _tlOcounter = rule309 _hdIcounter
         _tlOnamesInScope = rule310 _lhsInamesInScope
         __result_ = T_Constructors_vOut19 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Constructors_s20 v19
   {-# INLINE rule303 #-}
   rule303 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule304 #-}
   rule304 = \ ((_hdIself) :: Constructor) ((_tlIself) :: Constructors) ->
     (:) _hdIself _tlIself
   {-# INLINE rule305 #-}
   rule305 = \ _self ->
     _self
   {-# INLINE rule306 #-}
   rule306 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule307 #-}
   rule307 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule308 #-}
   rule308 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule309 #-}
   rule309 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule310 #-}
   rule310 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_Constructors_Nil #-}
sem_Constructors_Nil ::  T_Constructors 
sem_Constructors_Nil  = T_Constructors (return st20) where
   {-# NOINLINE st20 #-}
   st20 = let
      v19 :: T_Constructors_v19 
      v19 = \ (T_Constructors_vIn19 _lhsIcounter _lhsInamesInScope) -> ( let
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule311  ()
         _self = rule312  ()
         _lhsOself :: Constructors
         _lhsOself = rule313 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule314 _lhsIcounter
         __result_ = T_Constructors_vOut19 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Constructors_s20 v19
   {-# INLINE rule311 #-}
   rule311 = \  (_ :: ()) ->
     []
   {-# INLINE rule312 #-}
   rule312 = \  (_ :: ()) ->
     []
   {-# INLINE rule313 #-}
   rule313 = \ _self ->
     _self
   {-# INLINE rule314 #-}
   rule314 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter

-- ContextItem -------------------------------------------------
-- wrapper
data Inh_ContextItem  = Inh_ContextItem {  }
data Syn_ContextItem  = Syn_ContextItem { self_Syn_ContextItem :: (ContextItem) }
{-# INLINABLE wrap_ContextItem #-}
wrap_ContextItem :: T_ContextItem  -> Inh_ContextItem  -> (Syn_ContextItem )
wrap_ContextItem (T_ContextItem act) (Inh_ContextItem ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_ContextItem_vIn22 
        (T_ContextItem_vOut22 _lhsOself) <- return (inv_ContextItem_s23 sem arg)
        return (Syn_ContextItem _lhsOself)
   )

-- cata
{-# NOINLINE sem_ContextItem #-}
sem_ContextItem :: ContextItem  -> T_ContextItem 
sem_ContextItem ( ContextItem_ContextItem range_ name_ types_ ) = sem_ContextItem_ContextItem ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Types types_ )

-- semantic domain
newtype T_ContextItem  = T_ContextItem {
                                       attach_T_ContextItem :: Identity (T_ContextItem_s23 )
                                       }
newtype T_ContextItem_s23  = C_ContextItem_s23 {
                                               inv_ContextItem_s23 :: (T_ContextItem_v22 )
                                               }
data T_ContextItem_s24  = C_ContextItem_s24
type T_ContextItem_v22  = (T_ContextItem_vIn22 ) -> (T_ContextItem_vOut22 )
data T_ContextItem_vIn22  = T_ContextItem_vIn22 
data T_ContextItem_vOut22  = T_ContextItem_vOut22 (ContextItem)
{-# NOINLINE sem_ContextItem_ContextItem #-}
sem_ContextItem_ContextItem :: T_Range  -> T_Name  -> T_Types  -> T_ContextItem 
sem_ContextItem_ContextItem arg_range_ arg_name_ arg_types_ = T_ContextItem (return st23) where
   {-# NOINLINE st23 #-}
   st23 = let
      v22 :: T_ContextItem_v22 
      v22 = \ (T_ContextItem_vIn22 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _typesX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_types_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Types_vOut166 _typesIself) = inv_Types_s167 _typesX167 (T_Types_vIn166 )
         _tyconEnv = rule315  ()
         _self = rule316 _nameIself _rangeIself _typesIself
         _lhsOself :: ContextItem
         _lhsOself = rule317 _self
         __result_ = T_ContextItem_vOut22 _lhsOself
         in __result_ )
     in C_ContextItem_s23 v22
   {-# INLINE rule315 #-}
   rule315 = \  (_ :: ()) ->
                                        internalError "PartialSyntax.ag" "n/a" "ContextItem.ContextItem"
   {-# INLINE rule316 #-}
   rule316 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_typesIself) :: Types) ->
     ContextItem_ContextItem _rangeIself _nameIself _typesIself
   {-# INLINE rule317 #-}
   rule317 = \ _self ->
     _self

-- ContextItems ------------------------------------------------
-- wrapper
data Inh_ContextItems  = Inh_ContextItems {  }
data Syn_ContextItems  = Syn_ContextItems { self_Syn_ContextItems :: (ContextItems) }
{-# INLINABLE wrap_ContextItems #-}
wrap_ContextItems :: T_ContextItems  -> Inh_ContextItems  -> (Syn_ContextItems )
wrap_ContextItems (T_ContextItems act) (Inh_ContextItems ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_ContextItems_vIn25 
        (T_ContextItems_vOut25 _lhsOself) <- return (inv_ContextItems_s26 sem arg)
        return (Syn_ContextItems _lhsOself)
   )

-- cata
{-# NOINLINE sem_ContextItems #-}
sem_ContextItems :: ContextItems  -> T_ContextItems 
sem_ContextItems list = Prelude.foldr sem_ContextItems_Cons sem_ContextItems_Nil (Prelude.map sem_ContextItem list)

-- semantic domain
newtype T_ContextItems  = T_ContextItems {
                                         attach_T_ContextItems :: Identity (T_ContextItems_s26 )
                                         }
newtype T_ContextItems_s26  = C_ContextItems_s26 {
                                                 inv_ContextItems_s26 :: (T_ContextItems_v25 )
                                                 }
data T_ContextItems_s27  = C_ContextItems_s27
type T_ContextItems_v25  = (T_ContextItems_vIn25 ) -> (T_ContextItems_vOut25 )
data T_ContextItems_vIn25  = T_ContextItems_vIn25 
data T_ContextItems_vOut25  = T_ContextItems_vOut25 (ContextItems)
{-# NOINLINE sem_ContextItems_Cons #-}
sem_ContextItems_Cons :: T_ContextItem  -> T_ContextItems  -> T_ContextItems 
sem_ContextItems_Cons arg_hd_ arg_tl_ = T_ContextItems (return st26) where
   {-# NOINLINE st26 #-}
   st26 = let
      v25 :: T_ContextItems_v25 
      v25 = \ (T_ContextItems_vIn25 ) -> ( let
         _hdX23 = Control.Monad.Identity.runIdentity (attach_T_ContextItem (arg_hd_))
         _tlX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_tl_))
         (T_ContextItem_vOut22 _hdIself) = inv_ContextItem_s23 _hdX23 (T_ContextItem_vIn22 )
         (T_ContextItems_vOut25 _tlIself) = inv_ContextItems_s26 _tlX26 (T_ContextItems_vIn25 )
         _self = rule318 _hdIself _tlIself
         _lhsOself :: ContextItems
         _lhsOself = rule319 _self
         __result_ = T_ContextItems_vOut25 _lhsOself
         in __result_ )
     in C_ContextItems_s26 v25
   {-# INLINE rule318 #-}
   rule318 = \ ((_hdIself) :: ContextItem) ((_tlIself) :: ContextItems) ->
     (:) _hdIself _tlIself
   {-# INLINE rule319 #-}
   rule319 = \ _self ->
     _self
{-# NOINLINE sem_ContextItems_Nil #-}
sem_ContextItems_Nil ::  T_ContextItems 
sem_ContextItems_Nil  = T_ContextItems (return st26) where
   {-# NOINLINE st26 #-}
   st26 = let
      v25 :: T_ContextItems_v25 
      v25 = \ (T_ContextItems_vIn25 ) -> ( let
         _self = rule320  ()
         _lhsOself :: ContextItems
         _lhsOself = rule321 _self
         __result_ = T_ContextItems_vOut25 _lhsOself
         in __result_ )
     in C_ContextItems_s26 v25
   {-# INLINE rule320 #-}
   rule320 = \  (_ :: ()) ->
     []
   {-# INLINE rule321 #-}
   rule321 = \ _self ->
     _self

-- Declaration -------------------------------------------------
-- wrapper
data Inh_Declaration  = Inh_Declaration { allPatterns_Inh_Declaration :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Declaration :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Declaration :: (Predicates), betaUnique_Inh_Declaration :: (Int), bindingGroups_Inh_Declaration :: (BindingGroups), classEnvironment_Inh_Declaration :: (ClassEnvironment), collectErrors_Inh_Declaration :: (TypeErrors), collectWarnings_Inh_Declaration :: (Warnings), counter_Inh_Declaration :: (Int), currentChunk_Inh_Declaration :: (Int), dictionaryEnvironment_Inh_Declaration :: (DictionaryEnvironment), importEnvironment_Inh_Declaration :: (ImportEnvironment), inheritedBDG_Inh_Declaration :: (InheritedBDG), matchIO_Inh_Declaration :: (IO ()), monos_Inh_Declaration :: (Monos), namesInScope_Inh_Declaration :: (Names), orderedTypeSynonyms_Inh_Declaration :: (OrderedTypeSynonyms), parentTree_Inh_Declaration :: (InfoTree), patternMatchWarnings_Inh_Declaration :: ([Warning]), substitution_Inh_Declaration :: (FixpointSubstitution), typeSignatures_Inh_Declaration :: (TypeEnvironment), typeschemeMap_Inh_Declaration :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Declaration :: (Int) }
data Syn_Declaration  = Syn_Declaration { betaUnique_Syn_Declaration :: (Int), bindingGroups_Syn_Declaration :: (BindingGroups), collectErrors_Syn_Declaration :: (TypeErrors), collectInstances_Syn_Declaration :: ([(Name, Instance)]), collectWarnings_Syn_Declaration :: (Warnings), counter_Syn_Declaration :: (Int), declVarNames_Syn_Declaration :: (Names), dictionaryEnvironment_Syn_Declaration :: (DictionaryEnvironment), infoTrees_Syn_Declaration :: (InfoTrees), matchIO_Syn_Declaration :: (IO ()), patternMatchWarnings_Syn_Declaration :: ([Warning]), restrictedNames_Syn_Declaration :: (Names), self_Syn_Declaration :: (Declaration), simplePatNames_Syn_Declaration :: (Names), typeSignatures_Syn_Declaration :: (TypeEnvironment), unboundNames_Syn_Declaration :: (Names), uniqueChunk_Syn_Declaration :: (Int) }
{-# INLINABLE wrap_Declaration #-}
wrap_Declaration :: T_Declaration  -> Inh_Declaration  -> (Syn_Declaration )
wrap_Declaration (T_Declaration act) (Inh_Declaration _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk
        (T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_Declaration_s29 sem arg)
        return (Syn_Declaration _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_Declaration #-}
sem_Declaration :: Declaration  -> T_Declaration 
sem_Declaration ( Declaration_Hole range_ id_ ) = sem_Declaration_Hole ( sem_Range range_ ) id_
sem_Declaration ( Declaration_Type range_ simpletype_ type_ ) = sem_Declaration_Type ( sem_Range range_ ) ( sem_SimpleType simpletype_ ) ( sem_Type type_ )
sem_Declaration ( Declaration_Data range_ context_ simpletype_ constructors_ derivings_ ) = sem_Declaration_Data ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_SimpleType simpletype_ ) ( sem_Constructors constructors_ ) ( sem_Names derivings_ )
sem_Declaration ( Declaration_Newtype range_ context_ simpletype_ constructor_ derivings_ ) = sem_Declaration_Newtype ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_SimpleType simpletype_ ) ( sem_Constructor constructor_ ) ( sem_Names derivings_ )
sem_Declaration ( Declaration_Class range_ context_ simpletype_ where_ ) = sem_Declaration_Class ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_SimpleType simpletype_ ) ( sem_MaybeDeclarations where_ )
sem_Declaration ( Declaration_Instance range_ context_ name_ types_ where_ ) = sem_Declaration_Instance ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_Name name_ ) ( sem_Types types_ ) ( sem_MaybeDeclarations where_ )
sem_Declaration ( Declaration_Default range_ types_ ) = sem_Declaration_Default ( sem_Range range_ ) ( sem_Types types_ )
sem_Declaration ( Declaration_FunctionBindings range_ bindings_ ) = sem_Declaration_FunctionBindings ( sem_Range range_ ) ( sem_FunctionBindings bindings_ )
sem_Declaration ( Declaration_PatternBinding range_ pattern_ righthandside_ ) = sem_Declaration_PatternBinding ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_RightHandSide righthandside_ )
sem_Declaration ( Declaration_TypeSignature range_ names_ type_ ) = sem_Declaration_TypeSignature ( sem_Range range_ ) ( sem_Names names_ ) ( sem_Type type_ )
sem_Declaration ( Declaration_Fixity range_ fixity_ priority_ operators_ ) = sem_Declaration_Fixity ( sem_Range range_ ) ( sem_Fixity fixity_ ) ( sem_MaybeInt priority_ ) ( sem_Names operators_ )
sem_Declaration ( Declaration_Empty range_ ) = sem_Declaration_Empty ( sem_Range range_ )

-- semantic domain
newtype T_Declaration  = T_Declaration {
                                       attach_T_Declaration :: Identity (T_Declaration_s29 )
                                       }
newtype T_Declaration_s29  = C_Declaration_s29 {
                                               inv_Declaration_s29 :: (T_Declaration_v28 )
                                               }
data T_Declaration_s30  = C_Declaration_s30
type T_Declaration_v28  = (T_Declaration_vIn28 ) -> (T_Declaration_vOut28 )
data T_Declaration_vIn28  = T_Declaration_vIn28 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (BindingGroups) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (InheritedBDG) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (TypeEnvironment) (M.Map Int (Scheme Predicates)) (Int)
data T_Declaration_vOut28  = T_Declaration_vOut28 (Int) (BindingGroups) (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (Names) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Warning]) (Names) (Declaration) (Names) (TypeEnvironment) (Names) (Int)
{-# NOINLINE sem_Declaration_Hole #-}
sem_Declaration_Hole :: T_Range  -> (Integer) -> T_Declaration 
sem_Declaration_Hole arg_range_ arg_id_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule322  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule323  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule324  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule325  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule326  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule327  ()
         _self = rule328 _rangeIself arg_id_
         _lhsOself :: Declaration
         _lhsOself = rule329 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule330 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule331 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule332 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule333 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule334 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule335 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule336 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule337 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule338 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule339 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule322 #-}
   rule322 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule323 #-}
   rule323 = \  (_ :: ()) ->
     []
   {-# INLINE rule324 #-}
   rule324 = \  (_ :: ()) ->
     []
   {-# INLINE rule325 #-}
   rule325 = \  (_ :: ()) ->
     []
   {-# INLINE rule326 #-}
   rule326 = \  (_ :: ()) ->
     []
   {-# INLINE rule327 #-}
   rule327 = \  (_ :: ()) ->
     []
   {-# INLINE rule328 #-}
   rule328 = \ ((_rangeIself) :: Range) id_ ->
     Declaration_Hole _rangeIself id_
   {-# INLINE rule329 #-}
   rule329 = \ _self ->
     _self
   {-# INLINE rule330 #-}
   rule330 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule331 #-}
   rule331 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule332 #-}
   rule332 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule333 #-}
   rule333 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule334 #-}
   rule334 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule335 #-}
   rule335 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule336 #-}
   rule336 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule337 #-}
   rule337 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule338 #-}
   rule338 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule339 #-}
   rule339 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Type #-}
sem_Declaration_Type :: T_Range  -> T_SimpleType  -> T_Type  -> T_Declaration 
sem_Declaration_Type arg_range_ arg_simpletype_ arg_type_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule340  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule341  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule342  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule343  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule344  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule345  ()
         _self = rule346 _rangeIself _simpletypeIself _typeIself
         _lhsOself :: Declaration
         _lhsOself = rule347 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule348 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule349 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule350 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule351 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule352 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule353 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule354 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule355 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule356 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule357 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule340 #-}
   rule340 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule341 #-}
   rule341 = \  (_ :: ()) ->
     []
   {-# INLINE rule342 #-}
   rule342 = \  (_ :: ()) ->
     []
   {-# INLINE rule343 #-}
   rule343 = \  (_ :: ()) ->
     []
   {-# INLINE rule344 #-}
   rule344 = \  (_ :: ()) ->
     []
   {-# INLINE rule345 #-}
   rule345 = \  (_ :: ()) ->
     []
   {-# INLINE rule346 #-}
   rule346 = \ ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ((_typeIself) :: Type) ->
     Declaration_Type _rangeIself _simpletypeIself _typeIself
   {-# INLINE rule347 #-}
   rule347 = \ _self ->
     _self
   {-# INLINE rule348 #-}
   rule348 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule349 #-}
   rule349 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule350 #-}
   rule350 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule351 #-}
   rule351 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule352 #-}
   rule352 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule353 #-}
   rule353 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule354 #-}
   rule354 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule355 #-}
   rule355 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule356 #-}
   rule356 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule357 #-}
   rule357 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Data #-}
sem_Declaration_Data :: T_Range  -> T_ContextItems  -> T_SimpleType  -> T_Constructors  -> T_Names  -> T_Declaration 
sem_Declaration_Data arg_range_ arg_context_ arg_simpletype_ arg_constructors_ arg_derivings_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
         _simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
         _constructorsX20 = Control.Monad.Identity.runIdentity (attach_T_Constructors (arg_constructors_))
         _derivingsX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_derivings_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
         (T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
         (T_Constructors_vOut19 _constructorsIcounter _constructorsIself _constructorsIunboundNames) = inv_Constructors_s20 _constructorsX20 (T_Constructors_vIn19 _constructorsOcounter _constructorsOnamesInScope)
         (T_Names_vOut115 _derivingsIself) = inv_Names_s116 _derivingsX116 (T_Names_vIn115 )
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule358 _derivingsIself _simpletypeIname _simpletypeItypevariables
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule359  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule360  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule361  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule362  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule363 _constructorsIunboundNames
         _self = rule364 _constructorsIself _contextIself _derivingsIself _rangeIself _simpletypeIself
         _lhsOself :: Declaration
         _lhsOself = rule365 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule366 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule367 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule368 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule369 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule370 _constructorsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule371 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule372 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule373 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule374 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule375 _lhsIuniqueChunk
         _constructorsOcounter = rule376 _lhsIcounter
         _constructorsOnamesInScope = rule377 _lhsInamesInScope
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule358 #-}
   rule358 = \ ((_derivingsIself) :: Names) ((_simpletypeIname) :: Name) ((_simpletypeItypevariables) :: Names) ->
                                  [ (cl, makeInstance (show cl) (length _simpletypeItypevariables) (show _simpletypeIname) )
                                  | cl <- _derivingsIself
                                  ]
   {-# INLINE rule359 #-}
   rule359 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule360 #-}
   rule360 = \  (_ :: ()) ->
     []
   {-# INLINE rule361 #-}
   rule361 = \  (_ :: ()) ->
     []
   {-# INLINE rule362 #-}
   rule362 = \  (_ :: ()) ->
     []
   {-# INLINE rule363 #-}
   rule363 = \ ((_constructorsIunboundNames) :: Names) ->
     _constructorsIunboundNames
   {-# INLINE rule364 #-}
   rule364 = \ ((_constructorsIself) :: Constructors) ((_contextIself) :: ContextItems) ((_derivingsIself) :: Names) ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ->
     Declaration_Data _rangeIself _contextIself _simpletypeIself _constructorsIself _derivingsIself
   {-# INLINE rule365 #-}
   rule365 = \ _self ->
     _self
   {-# INLINE rule366 #-}
   rule366 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule367 #-}
   rule367 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule368 #-}
   rule368 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule369 #-}
   rule369 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule370 #-}
   rule370 = \ ((_constructorsIcounter) :: Int) ->
     _constructorsIcounter
   {-# INLINE rule371 #-}
   rule371 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule372 #-}
   rule372 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule373 #-}
   rule373 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule374 #-}
   rule374 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule375 #-}
   rule375 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule376 #-}
   rule376 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule377 #-}
   rule377 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_Declaration_Newtype #-}
sem_Declaration_Newtype :: T_Range  -> T_ContextItems  -> T_SimpleType  -> T_Constructor  -> T_Names  -> T_Declaration 
sem_Declaration_Newtype arg_range_ arg_context_ arg_simpletype_ arg_constructor_ arg_derivings_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
         _simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
         _constructorX17 = Control.Monad.Identity.runIdentity (attach_T_Constructor (arg_constructor_))
         _derivingsX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_derivings_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
         (T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
         (T_Constructor_vOut16 _constructorIcounter _constructorIself _constructorIunboundNames) = inv_Constructor_s17 _constructorX17 (T_Constructor_vIn16 _constructorOcounter _constructorOnamesInScope)
         (T_Names_vOut115 _derivingsIself) = inv_Names_s116 _derivingsX116 (T_Names_vIn115 )
         _infoTrees = rule378  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule379  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule380  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule381  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule382  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule383 _constructorIunboundNames
         _self = rule384 _constructorIself _contextIself _derivingsIself _rangeIself _simpletypeIself
         _lhsOself :: Declaration
         _lhsOself = rule385 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule386 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule387 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule388 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule389 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule390 _constructorIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule391 _lhsIdictionaryEnvironment
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule392 _infoTrees
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule393 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule394 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule395 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule396 _lhsIuniqueChunk
         _constructorOcounter = rule397 _lhsIcounter
         _constructorOnamesInScope = rule398 _lhsInamesInScope
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule378 #-}
   rule378 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule379 #-}
   rule379 = \  (_ :: ()) ->
     []
   {-# INLINE rule380 #-}
   rule380 = \  (_ :: ()) ->
     []
   {-# INLINE rule381 #-}
   rule381 = \  (_ :: ()) ->
     []
   {-# INLINE rule382 #-}
   rule382 = \  (_ :: ()) ->
     []
   {-# INLINE rule383 #-}
   rule383 = \ ((_constructorIunboundNames) :: Names) ->
     _constructorIunboundNames
   {-# INLINE rule384 #-}
   rule384 = \ ((_constructorIself) :: Constructor) ((_contextIself) :: ContextItems) ((_derivingsIself) :: Names) ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ->
     Declaration_Newtype _rangeIself _contextIself _simpletypeIself _constructorIself _derivingsIself
   {-# INLINE rule385 #-}
   rule385 = \ _self ->
     _self
   {-# INLINE rule386 #-}
   rule386 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule387 #-}
   rule387 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule388 #-}
   rule388 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule389 #-}
   rule389 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule390 #-}
   rule390 = \ ((_constructorIcounter) :: Int) ->
     _constructorIcounter
   {-# INLINE rule391 #-}
   rule391 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule392 #-}
   rule392 = \ _infoTrees ->
     _infoTrees
   {-# INLINE rule393 #-}
   rule393 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule394 #-}
   rule394 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule395 #-}
   rule395 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule396 #-}
   rule396 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule397 #-}
   rule397 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule398 #-}
   rule398 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_Declaration_Class #-}
sem_Declaration_Class :: T_Range  -> T_ContextItems  -> T_SimpleType  -> T_MaybeDeclarations  -> T_Declaration 
sem_Declaration_Class arg_range_ arg_context_ arg_simpletype_ arg_where_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
         _simpletypeX152 = Control.Monad.Identity.runIdentity (attach_T_SimpleType (arg_simpletype_))
         _whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
         (T_SimpleType_vOut151 _simpletypeIname _simpletypeIself _simpletypeItypevariables) = inv_SimpleType_s152 _simpletypeX152 (T_SimpleType_vIn151 )
         (T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
         (_assumptions,_constraints,_unboundNames) = rule399  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule400 _whereIcollectInstances
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule401  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule402  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule403  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule404 _unboundNames
         _self = rule405 _contextIself _rangeIself _simpletypeIself _whereIself
         _lhsOself :: Declaration
         _lhsOself = rule406 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule407 _whereIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule408 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule409 _whereIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule410 _whereIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule411 _whereIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule412 _whereIdictionaryEnvironment
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule413 _whereIinfoTrees
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule414 _whereImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule415 _whereIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule416 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule417 _whereIuniqueChunk
         _whereOallPatterns = rule418 _lhsIallPatterns
         _whereOallTypeSchemes = rule419 _lhsIallTypeSchemes
         _whereOassumptions = rule420 _assumptions
         _whereOavailablePredicates = rule421 _lhsIavailablePredicates
         _whereObetaUnique = rule422 _lhsIbetaUnique
         _whereOclassEnvironment = rule423 _lhsIclassEnvironment
         _whereOcollectErrors = rule424 _lhsIcollectErrors
         _whereOcollectWarnings = rule425 _lhsIcollectWarnings
         _whereOconstraints = rule426 _constraints
         _whereOcounter = rule427 _lhsIcounter
         _whereOcurrentChunk = rule428 _lhsIcurrentChunk
         _whereOdictionaryEnvironment = rule429 _lhsIdictionaryEnvironment
         _whereOimportEnvironment = rule430 _lhsIimportEnvironment
         _whereOmatchIO = rule431 _lhsImatchIO
         _whereOmonos = rule432 _lhsImonos
         _whereOnamesInScope = rule433 _lhsInamesInScope
         _whereOorderedTypeSynonyms = rule434 _lhsIorderedTypeSynonyms
         _whereOparentTree = rule435 _lhsIparentTree
         _whereOpatternMatchWarnings = rule436 _lhsIpatternMatchWarnings
         _whereOsubstitution = rule437 _lhsIsubstitution
         _whereOtypeschemeMap = rule438 _lhsItypeschemeMap
         _whereOunboundNames = rule439 _unboundNames
         _whereOuniqueChunk = rule440 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule399 #-}
   rule399 = \  (_ :: ()) ->
                                                               internalError "PartialSyntax.ag" "n/a" "Declaration.Class"
   {-# INLINE rule400 #-}
   rule400 = \ ((_whereIcollectInstances) :: [(Name, Instance)]) ->
     _whereIcollectInstances
   {-# INLINE rule401 #-}
   rule401 = \  (_ :: ()) ->
     []
   {-# INLINE rule402 #-}
   rule402 = \  (_ :: ()) ->
     []
   {-# INLINE rule403 #-}
   rule403 = \  (_ :: ()) ->
     []
   {-# INLINE rule404 #-}
   rule404 = \ _unboundNames ->
     _unboundNames
   {-# INLINE rule405 #-}
   rule405 = \ ((_contextIself) :: ContextItems) ((_rangeIself) :: Range) ((_simpletypeIself) :: SimpleType) ((_whereIself) :: MaybeDeclarations) ->
     Declaration_Class _rangeIself _contextIself _simpletypeIself _whereIself
   {-# INLINE rule406 #-}
   rule406 = \ _self ->
     _self
   {-# INLINE rule407 #-}
   rule407 = \ ((_whereIbetaUnique) :: Int) ->
     _whereIbetaUnique
   {-# INLINE rule408 #-}
   rule408 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule409 #-}
   rule409 = \ ((_whereIcollectErrors) :: TypeErrors) ->
     _whereIcollectErrors
   {-# INLINE rule410 #-}
   rule410 = \ ((_whereIcollectWarnings) :: Warnings) ->
     _whereIcollectWarnings
   {-# INLINE rule411 #-}
   rule411 = \ ((_whereIcounter) :: Int) ->
     _whereIcounter
   {-# INLINE rule412 #-}
   rule412 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _whereIdictionaryEnvironment
   {-# INLINE rule413 #-}
   rule413 = \ ((_whereIinfoTrees) :: InfoTrees) ->
     _whereIinfoTrees
   {-# INLINE rule414 #-}
   rule414 = \ ((_whereImatchIO) :: IO ()) ->
     _whereImatchIO
   {-# INLINE rule415 #-}
   rule415 = \ ((_whereIpatternMatchWarnings) :: [Warning]) ->
     _whereIpatternMatchWarnings
   {-# INLINE rule416 #-}
   rule416 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule417 #-}
   rule417 = \ ((_whereIuniqueChunk) :: Int) ->
     _whereIuniqueChunk
   {-# INLINE rule418 #-}
   rule418 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule419 #-}
   rule419 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule420 #-}
   rule420 = \ _assumptions ->
     _assumptions
   {-# INLINE rule421 #-}
   rule421 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule422 #-}
   rule422 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule423 #-}
   rule423 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule424 #-}
   rule424 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule425 #-}
   rule425 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule426 #-}
   rule426 = \ _constraints ->
     _constraints
   {-# INLINE rule427 #-}
   rule427 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule428 #-}
   rule428 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule429 #-}
   rule429 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule430 #-}
   rule430 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule431 #-}
   rule431 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule432 #-}
   rule432 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule433 #-}
   rule433 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule434 #-}
   rule434 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule435 #-}
   rule435 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule436 #-}
   rule436 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule437 #-}
   rule437 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule438 #-}
   rule438 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule439 #-}
   rule439 = \ _unboundNames ->
     _unboundNames
   {-# INLINE rule440 #-}
   rule440 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Instance #-}
sem_Declaration_Instance :: T_Range  -> T_ContextItems  -> T_Name  -> T_Types  -> T_MaybeDeclarations  -> T_Declaration 
sem_Declaration_Instance arg_range_ arg_context_ arg_name_ arg_types_ arg_where_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _typesX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_types_))
         _whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Types_vOut166 _typesIself) = inv_Types_s167 _typesX167 (T_Types_vIn166 )
         (T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
         (_assumptions,_constraints,_unboundNames) = rule441  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule442 _whereIcollectInstances
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule443  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule444  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule445  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule446 _unboundNames
         _self = rule447 _contextIself _nameIself _rangeIself _typesIself _whereIself
         _lhsOself :: Declaration
         _lhsOself = rule448 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule449 _whereIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule450 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule451 _whereIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule452 _whereIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule453 _whereIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule454 _whereIdictionaryEnvironment
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule455 _whereIinfoTrees
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule456 _whereImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule457 _whereIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule458 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule459 _whereIuniqueChunk
         _whereOallPatterns = rule460 _lhsIallPatterns
         _whereOallTypeSchemes = rule461 _lhsIallTypeSchemes
         _whereOassumptions = rule462 _assumptions
         _whereOavailablePredicates = rule463 _lhsIavailablePredicates
         _whereObetaUnique = rule464 _lhsIbetaUnique
         _whereOclassEnvironment = rule465 _lhsIclassEnvironment
         _whereOcollectErrors = rule466 _lhsIcollectErrors
         _whereOcollectWarnings = rule467 _lhsIcollectWarnings
         _whereOconstraints = rule468 _constraints
         _whereOcounter = rule469 _lhsIcounter
         _whereOcurrentChunk = rule470 _lhsIcurrentChunk
         _whereOdictionaryEnvironment = rule471 _lhsIdictionaryEnvironment
         _whereOimportEnvironment = rule472 _lhsIimportEnvironment
         _whereOmatchIO = rule473 _lhsImatchIO
         _whereOmonos = rule474 _lhsImonos
         _whereOnamesInScope = rule475 _lhsInamesInScope
         _whereOorderedTypeSynonyms = rule476 _lhsIorderedTypeSynonyms
         _whereOparentTree = rule477 _lhsIparentTree
         _whereOpatternMatchWarnings = rule478 _lhsIpatternMatchWarnings
         _whereOsubstitution = rule479 _lhsIsubstitution
         _whereOtypeschemeMap = rule480 _lhsItypeschemeMap
         _whereOunboundNames = rule481 _unboundNames
         _whereOuniqueChunk = rule482 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule441 #-}
   rule441 = \  (_ :: ()) ->
                                                               internalError "PartialSyntax.ag" "n/a" "Declaration.Instance"
   {-# INLINE rule442 #-}
   rule442 = \ ((_whereIcollectInstances) :: [(Name, Instance)]) ->
     _whereIcollectInstances
   {-# INLINE rule443 #-}
   rule443 = \  (_ :: ()) ->
     []
   {-# INLINE rule444 #-}
   rule444 = \  (_ :: ()) ->
     []
   {-# INLINE rule445 #-}
   rule445 = \  (_ :: ()) ->
     []
   {-# INLINE rule446 #-}
   rule446 = \ _unboundNames ->
     _unboundNames
   {-# INLINE rule447 #-}
   rule447 = \ ((_contextIself) :: ContextItems) ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_typesIself) :: Types) ((_whereIself) :: MaybeDeclarations) ->
     Declaration_Instance _rangeIself _contextIself _nameIself _typesIself _whereIself
   {-# INLINE rule448 #-}
   rule448 = \ _self ->
     _self
   {-# INLINE rule449 #-}
   rule449 = \ ((_whereIbetaUnique) :: Int) ->
     _whereIbetaUnique
   {-# INLINE rule450 #-}
   rule450 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule451 #-}
   rule451 = \ ((_whereIcollectErrors) :: TypeErrors) ->
     _whereIcollectErrors
   {-# INLINE rule452 #-}
   rule452 = \ ((_whereIcollectWarnings) :: Warnings) ->
     _whereIcollectWarnings
   {-# INLINE rule453 #-}
   rule453 = \ ((_whereIcounter) :: Int) ->
     _whereIcounter
   {-# INLINE rule454 #-}
   rule454 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _whereIdictionaryEnvironment
   {-# INLINE rule455 #-}
   rule455 = \ ((_whereIinfoTrees) :: InfoTrees) ->
     _whereIinfoTrees
   {-# INLINE rule456 #-}
   rule456 = \ ((_whereImatchIO) :: IO ()) ->
     _whereImatchIO
   {-# INLINE rule457 #-}
   rule457 = \ ((_whereIpatternMatchWarnings) :: [Warning]) ->
     _whereIpatternMatchWarnings
   {-# INLINE rule458 #-}
   rule458 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule459 #-}
   rule459 = \ ((_whereIuniqueChunk) :: Int) ->
     _whereIuniqueChunk
   {-# INLINE rule460 #-}
   rule460 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule461 #-}
   rule461 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule462 #-}
   rule462 = \ _assumptions ->
     _assumptions
   {-# INLINE rule463 #-}
   rule463 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule464 #-}
   rule464 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule465 #-}
   rule465 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule466 #-}
   rule466 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule467 #-}
   rule467 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule468 #-}
   rule468 = \ _constraints ->
     _constraints
   {-# INLINE rule469 #-}
   rule469 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule470 #-}
   rule470 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule471 #-}
   rule471 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule472 #-}
   rule472 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule473 #-}
   rule473 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule474 #-}
   rule474 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule475 #-}
   rule475 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule476 #-}
   rule476 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule477 #-}
   rule477 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule478 #-}
   rule478 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule479 #-}
   rule479 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule480 #-}
   rule480 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule481 #-}
   rule481 = \ _unboundNames ->
     _unboundNames
   {-# INLINE rule482 #-}
   rule482 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Default #-}
sem_Declaration_Default :: T_Range  -> T_Types  -> T_Declaration 
sem_Declaration_Default arg_range_ arg_types_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _typesX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_types_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Types_vOut166 _typesIself) = inv_Types_s167 _typesX167 (T_Types_vIn166 )
         _infoTrees = rule483  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule484  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule485  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule486  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule487  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule488  ()
         _self = rule489 _rangeIself _typesIself
         _lhsOself :: Declaration
         _lhsOself = rule490 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule491 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule492 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule493 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule494 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule495 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule496 _lhsIdictionaryEnvironment
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule497 _infoTrees
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule498 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule499 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule500 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule501 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule483 #-}
   rule483 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule484 #-}
   rule484 = \  (_ :: ()) ->
     []
   {-# INLINE rule485 #-}
   rule485 = \  (_ :: ()) ->
     []
   {-# INLINE rule486 #-}
   rule486 = \  (_ :: ()) ->
     []
   {-# INLINE rule487 #-}
   rule487 = \  (_ :: ()) ->
     []
   {-# INLINE rule488 #-}
   rule488 = \  (_ :: ()) ->
     []
   {-# INLINE rule489 #-}
   rule489 = \ ((_rangeIself) :: Range) ((_typesIself) :: Types) ->
     Declaration_Default _rangeIself _typesIself
   {-# INLINE rule490 #-}
   rule490 = \ _self ->
     _self
   {-# INLINE rule491 #-}
   rule491 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule492 #-}
   rule492 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule493 #-}
   rule493 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule494 #-}
   rule494 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule495 #-}
   rule495 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule496 #-}
   rule496 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule497 #-}
   rule497 = \ _infoTrees ->
     _infoTrees
   {-# INLINE rule498 #-}
   rule498 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule499 #-}
   rule499 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule500 #-}
   rule500 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule501 #-}
   rule501 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_FunctionBindings #-}
sem_Declaration_FunctionBindings :: T_Range  -> T_FunctionBindings  -> T_Declaration 
sem_Declaration_FunctionBindings arg_range_ arg_bindings_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _bindingsX59 = Control.Monad.Identity.runIdentity (attach_T_FunctionBindings (arg_bindings_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_FunctionBindings_vOut58 _bindingsIargcount _bindingsIassumptions _bindingsIbetaUnique _bindingsIcollectErrors _bindingsIcollectInstances _bindingsIcollectWarnings _bindingsIconstraintslist _bindingsIcounter _bindingsIdictionaryEnvironment _bindingsIelementss _bindingsIinfoTrees _bindingsImatchIO _bindingsIname _bindingsInumberOfPatterns _bindingsIpatternMatchWarnings _bindingsIself _bindingsIunboundNames _bindingsIuniqueChunk _bindingsIunrwars) = inv_FunctionBindings_s59 _bindingsX59 (T_FunctionBindings_vIn58 _bindingsOallPatterns _bindingsOallTypeSchemes _bindingsOavailablePredicates _bindingsObetaRight _bindingsObetaUnique _bindingsObetasLeft _bindingsOclassEnvironment _bindingsOcollectErrors _bindingsOcollectWarnings _bindingsOcounter _bindingsOcurrentChunk _bindingsOdictionaryEnvironment _bindingsOimportEnvironment _bindingsOmatchIO _bindingsOmonos _bindingsOnamesInScope _bindingsOorderedTypeSynonyms _bindingsOparentTree _bindingsOpatternMatchWarnings _bindingsOsubstitution _bindingsOtypeschemeMap _bindingsOuniqueChunk)
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule502 _lhsIbindingGroups _mybdggrp
         _bindingsObetaUnique = rule503 _bindingsInumberOfPatterns _lhsIbetaUnique
         _bindingsOmonos = rule504 _bindingsIname _lhsIinheritedBDG _lhsImonos
         _beta = rule505 _lhsIbetaUnique
         _betaRight = rule506 _lhsIbetaUnique
         _betasLeft = rule507 _bindingsInumberOfPatterns _lhsIbetaUnique
         _newcon = rule508 _beta _betaRight _betasLeft _cinfo
         _mybdggrp = rule509 _beta _bindingsIassumptions _bindingsIconstraintslist _bindingsIname _lhsIbetaUnique _newcon
         _declPredicates = rule510 _beta _bindingsIname _lhsIallTypeSchemes _lhsIorderedTypeSynonyms _lhsIsubstitution
         _bindingsOavailablePredicates = rule511 _declPredicates _lhsIavailablePredicates
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule512 _bindingsIdictionaryEnvironment _bindingsIname _declPredicates
         _bindingsOcurrentChunk = rule513 _bindingsIname _lhsIinheritedBDG
         _cinfo = rule514 _bindingsInumberOfPatterns _parentTree
         _localInfo = rule515 _lhsImonos _self
         _parentTree = rule516 _bindingsIinfoTrees _lhsIparentTree _localInfo
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule517 _parentTree
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule518 _bindingsIname
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule519 _beta _bindingsIargcount _bindingsIelementss _bindingsIname _bindingsIpatternMatchWarnings _bindingsIunrwars _lhsIimportEnvironment _lhsIsubstitution _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule520 _bindingsIcollectInstances
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule521  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule522  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule523 _bindingsIunboundNames
         _self = rule524 _bindingsIself _rangeIself
         _lhsOself :: Declaration
         _lhsOself = rule525 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule526 _bindingsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule527 _bindingsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule528 _bindingsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule529 _bindingsIcounter
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule530 _bindingsImatchIO
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule531 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule532 _bindingsIuniqueChunk
         _bindingsOallPatterns = rule533 _lhsIallPatterns
         _bindingsOallTypeSchemes = rule534 _lhsIallTypeSchemes
         _bindingsObetaRight = rule535 _betaRight
         _bindingsObetasLeft = rule536 _betasLeft
         _bindingsOclassEnvironment = rule537 _lhsIclassEnvironment
         _bindingsOcollectErrors = rule538 _lhsIcollectErrors
         _bindingsOcollectWarnings = rule539 _lhsIcollectWarnings
         _bindingsOcounter = rule540 _lhsIcounter
         _bindingsOdictionaryEnvironment = rule541 _lhsIdictionaryEnvironment
         _bindingsOimportEnvironment = rule542 _lhsIimportEnvironment
         _bindingsOmatchIO = rule543 _lhsImatchIO
         _bindingsOnamesInScope = rule544 _lhsInamesInScope
         _bindingsOorderedTypeSynonyms = rule545 _lhsIorderedTypeSynonyms
         _bindingsOparentTree = rule546 _parentTree
         _bindingsOpatternMatchWarnings = rule547 _lhsIpatternMatchWarnings
         _bindingsOsubstitution = rule548 _lhsIsubstitution
         _bindingsOtypeschemeMap = rule549 _lhsItypeschemeMap
         _bindingsOuniqueChunk = rule550 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule502 #-}
   rule502 = \ ((_lhsIbindingGroups) :: BindingGroups) _mybdggrp ->
                                   _mybdggrp : _lhsIbindingGroups
   {-# INLINE rule503 #-}
   rule503 = \ ((_bindingsInumberOfPatterns) :: Int) ((_lhsIbetaUnique) :: Int) ->
                                   _lhsIbetaUnique + 2 + _bindingsInumberOfPatterns
   {-# INLINE rule504 #-}
   rule504 = \ ((_bindingsIname) :: Name) ((_lhsIinheritedBDG) :: InheritedBDG) ((_lhsImonos) :: Monos) ->
                                   findMono _bindingsIname _lhsIinheritedBDG ++ _lhsImonos
   {-# INLINE rule505 #-}
   rule505 = \ ((_lhsIbetaUnique) :: Int) ->
                                   TVar _lhsIbetaUnique
   {-# INLINE rule506 #-}
   rule506 = \ ((_lhsIbetaUnique) :: Int) ->
                                   TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule507 #-}
   rule507 = \ ((_bindingsInumberOfPatterns) :: Int) ((_lhsIbetaUnique) :: Int) ->
                                   take _bindingsInumberOfPatterns (map TVar [_lhsIbetaUnique + 2..])
   {-# INLINE rule508 #-}
   rule508 = \ _beta _betaRight _betasLeft _cinfo ->
                                   (_beta .==. foldr (.->.) _betaRight _betasLeft) _cinfo
   {-# INLINE rule509 #-}
   rule509 = \ _beta ((_bindingsIassumptions) :: Assumptions) ((_bindingsIconstraintslist) :: ConstraintSets) ((_bindingsIname) :: Name) ((_lhsIbetaUnique) :: Int) _newcon ->
                                   ( M.singleton _bindingsIname _beta
                                   , _bindingsIassumptions
                                   , [ Node [ Phase (-1) [_newcon]
                                            , Receive _lhsIbetaUnique
                                            , Node _bindingsIconstraintslist
                                            ]
                                     ]
                                   )
   {-# INLINE rule510 #-}
   rule510 = \ _beta ((_bindingsIname) :: Name) ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ((_lhsIsubstitution) :: FixpointSubstitution) ->
                                            let scheme     = M.findWithDefault err (NameWithRange _bindingsIname) _lhsIallTypeSchemes
                                                predicates = matchTypeWithScheme _lhsIorderedTypeSynonyms
                                                                (_lhsIsubstitution |-> _beta)
                                                                (_lhsIsubstitution |-> scheme)
                                                err = internalError "TypeInferenceOverloading.ag" "n/a" "could not find type for function binding"
                                            in expandPredicates _lhsIorderedTypeSynonyms predicates
   {-# INLINE rule511 #-}
   rule511 = \ _declPredicates ((_lhsIavailablePredicates) :: Predicates) ->
                                            _declPredicates ++ _lhsIavailablePredicates
   {-# INLINE rule512 #-}
   rule512 = \ ((_bindingsIdictionaryEnvironment) :: DictionaryEnvironment) ((_bindingsIname) :: Name) _declPredicates ->
                                            addForDeclaration _bindingsIname _declPredicates _bindingsIdictionaryEnvironment
   {-# INLINE rule513 #-}
   rule513 = \ ((_bindingsIname) :: Name) ((_lhsIinheritedBDG) :: InheritedBDG) ->
                                                        findCurrentChunk _bindingsIname _lhsIinheritedBDG
   {-# INLINE rule514 #-}
   rule514 = \ ((_bindingsInumberOfPatterns) :: Int) _parentTree ->
     resultConstraint "function bindings (INTERNAL ERROR)" _parentTree
        [ FolkloreConstraint, highlyTrusted, FuntionBindingEdge _bindingsInumberOfPatterns ]
   {-# INLINE rule515 #-}
   rule515 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Decl _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule516 #-}
   rule516 = \ ((_bindingsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                                             node _lhsIparentTree _localInfo _bindingsIinfoTrees
   {-# INLINE rule517 #-}
   rule517 = \ _parentTree ->
                                             [_parentTree]
   {-# INLINE rule518 #-}
   rule518 = \ ((_bindingsIname) :: Name) ->
                                             [_bindingsIname]
   {-# INLINE rule519 #-}
   rule519 = \ _beta ((_bindingsIargcount) :: Int) ((_bindingsIelementss) :: [([PatternElement], Bool)]) ((_bindingsIname) :: Name) ((_bindingsIpatternMatchWarnings) :: [Warning]) ((_bindingsIunrwars) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_rangeIself) :: Range) ->
                                                    patternMatchWarnings _lhsIimportEnvironment
                                                                         _lhsIsubstitution
                                                                         _beta
                                                                         (take _bindingsIargcount . fst . functionSpine)
                                                                         _bindingsIelementss
                                                                         _rangeIself
                                                                         (Just _bindingsIname)
                                                                         True
                                                                         _bindingsIunrwars
                                                                         "function bindings"
                                                                         "="
                                                    ++ _bindingsIpatternMatchWarnings
   {-# INLINE rule520 #-}
   rule520 = \ ((_bindingsIcollectInstances) :: [(Name, Instance)]) ->
     _bindingsIcollectInstances
   {-# INLINE rule521 #-}
   rule521 = \  (_ :: ()) ->
     []
   {-# INLINE rule522 #-}
   rule522 = \  (_ :: ()) ->
     []
   {-# INLINE rule523 #-}
   rule523 = \ ((_bindingsIunboundNames) :: Names) ->
     _bindingsIunboundNames
   {-# INLINE rule524 #-}
   rule524 = \ ((_bindingsIself) :: FunctionBindings) ((_rangeIself) :: Range) ->
     Declaration_FunctionBindings _rangeIself _bindingsIself
   {-# INLINE rule525 #-}
   rule525 = \ _self ->
     _self
   {-# INLINE rule526 #-}
   rule526 = \ ((_bindingsIbetaUnique) :: Int) ->
     _bindingsIbetaUnique
   {-# INLINE rule527 #-}
   rule527 = \ ((_bindingsIcollectErrors) :: TypeErrors) ->
     _bindingsIcollectErrors
   {-# INLINE rule528 #-}
   rule528 = \ ((_bindingsIcollectWarnings) :: Warnings) ->
     _bindingsIcollectWarnings
   {-# INLINE rule529 #-}
   rule529 = \ ((_bindingsIcounter) :: Int) ->
     _bindingsIcounter
   {-# INLINE rule530 #-}
   rule530 = \ ((_bindingsImatchIO) :: IO ()) ->
     _bindingsImatchIO
   {-# INLINE rule531 #-}
   rule531 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule532 #-}
   rule532 = \ ((_bindingsIuniqueChunk) :: Int) ->
     _bindingsIuniqueChunk
   {-# INLINE rule533 #-}
   rule533 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule534 #-}
   rule534 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule535 #-}
   rule535 = \ _betaRight ->
     _betaRight
   {-# INLINE rule536 #-}
   rule536 = \ _betasLeft ->
     _betasLeft
   {-# INLINE rule537 #-}
   rule537 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule538 #-}
   rule538 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule539 #-}
   rule539 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule540 #-}
   rule540 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule541 #-}
   rule541 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule542 #-}
   rule542 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule543 #-}
   rule543 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule544 #-}
   rule544 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule545 #-}
   rule545 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule546 #-}
   rule546 = \ _parentTree ->
     _parentTree
   {-# INLINE rule547 #-}
   rule547 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule548 #-}
   rule548 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule549 #-}
   rule549 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule550 #-}
   rule550 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_PatternBinding #-}
sem_Declaration_PatternBinding :: T_Range  -> T_Pattern  -> T_RightHandSide  -> T_Declaration 
sem_Declaration_PatternBinding arg_range_ arg_pattern_ arg_righthandside_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         _righthandsideX149 = Control.Monad.Identity.runIdentity (attach_T_RightHandSide (arg_righthandside_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         (T_RightHandSide_vOut148 _righthandsideIassumptions _righthandsideIbetaUnique _righthandsideIcollectErrors _righthandsideIcollectInstances _righthandsideIcollectWarnings _righthandsideIconstraints _righthandsideIcounter _righthandsideIdictionaryEnvironment _righthandsideIfallthrough _righthandsideIinfoTree _righthandsideImatchIO _righthandsideIpatternMatchWarnings _righthandsideIself _righthandsideIunboundNames _righthandsideIuniqueChunk) = inv_RightHandSide_s149 _righthandsideX149 (T_RightHandSide_vIn148 _righthandsideOallPatterns _righthandsideOallTypeSchemes _righthandsideOavailablePredicates _righthandsideObetaRight _righthandsideObetaUnique _righthandsideOclassEnvironment _righthandsideOcollectErrors _righthandsideOcollectWarnings _righthandsideOcounter _righthandsideOcurrentChunk _righthandsideOdictionaryEnvironment _righthandsideOimportEnvironment _righthandsideOmatchIO _righthandsideOmonos _righthandsideOnamesInScope _righthandsideOorderedTypeSynonyms _righthandsideOparentTree _righthandsideOpatternMatchWarnings _righthandsideOsubstitution _righthandsideOtypeschemeMap _righthandsideOuniqueChunk)
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule551 _lhsIbindingGroups _mybdggrp
         _patternObetaUnique = rule552 _lhsIbetaUnique
         _righthandsideOmonos = rule553 _lhsIinheritedBDG _lhsImonos _patternIenvironment
         _betaRight = rule554 _lhsIbetaUnique
         _newcon = rule555 _betaRight _cinfo _patternIbeta
         _mybdggrp = rule556 _newcon _patternIconstraints _patternIenvironment _righthandsideIassumptions _righthandsideIconstraints
         _declPredicates = rule557 _betaRight _lhsIallTypeSchemes _lhsIorderedTypeSynonyms _lhsIsubstitution _patternIself
         _righthandsideOavailablePredicates = rule558 _declPredicates _lhsIavailablePredicates
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule559 _declPredicates _righthandsideIdictionaryEnvironment
         _lhsOrestrictedNames :: Names
         _lhsOsimplePatNames :: Names
         (_lhsOrestrictedNames,_lhsOsimplePatNames) = rule560 _patternIpatVarNames _patternIself
         _righthandsideOcurrentChunk = rule561 _lhsIinheritedBDG _patternIenvironment
         _cinfo = rule562 _parentTree
         _localInfo = rule563 _lhsImonos _self
         _parentTree = rule564 _lhsIparentTree _localInfo _patternIinfoTree _righthandsideIinfoTree
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule565 _parentTree
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule566 _patternIpatVarNames
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule567 _lhsIimportEnvironment _lhsIsubstitution _patternIbeta _patternIelements _rangeIself _righthandsideIfallthrough _righthandsideIpatternMatchWarnings
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule568 _righthandsideIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule569 _patternIunboundNames _righthandsideIunboundNames
         _self = rule570 _patternIself _rangeIself _righthandsideIself
         _lhsOself :: Declaration
         _lhsOself = rule571 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule572 _righthandsideIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule573 _righthandsideIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule574 _righthandsideIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule575 _righthandsideIcounter
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule576 _righthandsideImatchIO
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule577 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule578 _righthandsideIuniqueChunk
         _patternOcounter = rule579 _lhsIcounter
         _patternOimportEnvironment = rule580 _lhsIimportEnvironment
         _patternOmonos = rule581 _lhsImonos
         _patternOnamesInScope = rule582 _lhsInamesInScope
         _patternOparentTree = rule583 _parentTree
         _patternOpatternMatchWarnings = rule584 _lhsIpatternMatchWarnings
         _righthandsideOallPatterns = rule585 _lhsIallPatterns
         _righthandsideOallTypeSchemes = rule586 _lhsIallTypeSchemes
         _righthandsideObetaRight = rule587 _betaRight
         _righthandsideObetaUnique = rule588 _patternIbetaUnique
         _righthandsideOclassEnvironment = rule589 _lhsIclassEnvironment
         _righthandsideOcollectErrors = rule590 _lhsIcollectErrors
         _righthandsideOcollectWarnings = rule591 _lhsIcollectWarnings
         _righthandsideOcounter = rule592 _patternIcounter
         _righthandsideOdictionaryEnvironment = rule593 _lhsIdictionaryEnvironment
         _righthandsideOimportEnvironment = rule594 _lhsIimportEnvironment
         _righthandsideOmatchIO = rule595 _lhsImatchIO
         _righthandsideOnamesInScope = rule596 _lhsInamesInScope
         _righthandsideOorderedTypeSynonyms = rule597 _lhsIorderedTypeSynonyms
         _righthandsideOparentTree = rule598 _parentTree
         _righthandsideOpatternMatchWarnings = rule599 _patternIpatternMatchWarnings
         _righthandsideOsubstitution = rule600 _lhsIsubstitution
         _righthandsideOtypeschemeMap = rule601 _lhsItypeschemeMap
         _righthandsideOuniqueChunk = rule602 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule551 #-}
   rule551 = \ ((_lhsIbindingGroups) :: BindingGroups) _mybdggrp ->
                                        _mybdggrp : _lhsIbindingGroups
   {-# INLINE rule552 #-}
   rule552 = \ ((_lhsIbetaUnique) :: Int) ->
                                        _lhsIbetaUnique + 1
   {-# INLINE rule553 #-}
   rule553 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
                                        findMono (head (M.keys _patternIenvironment)) _lhsIinheritedBDG ++ _lhsImonos
   {-# INLINE rule554 #-}
   rule554 = \ ((_lhsIbetaUnique) :: Int) ->
                                        TVar _lhsIbetaUnique
   {-# INLINE rule555 #-}
   rule555 = \ _betaRight _cinfo ((_patternIbeta) :: Tp) ->
                                        [ (_betaRight .==. _patternIbeta) _cinfo ]
   {-# INLINE rule556 #-}
   rule556 = \ _newcon ((_patternIconstraints) :: ConstraintSet) ((_patternIenvironment) :: PatternAssumptions) ((_righthandsideIassumptions) :: Assumptions) ((_righthandsideIconstraints) :: ConstraintSet) ->
                                        ( _patternIenvironment
                                        , _righthandsideIassumptions
                                        , [ _newcon .>.
                                            Node [ _patternIconstraints
                                                 , _righthandsideIconstraints
                                                 ]
                                          ]
                                        )
   {-# INLINE rule557 #-}
   rule557 = \ _betaRight ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIself) :: Pattern) ->
                                          case _patternIself of
                                            Pattern_Variable _ name ->
                                               let scheme     = M.findWithDefault err (NameWithRange name) _lhsIallTypeSchemes
                                                   predicates = matchTypeWithScheme _lhsIorderedTypeSynonyms
                                                                   (_lhsIsubstitution |-> _betaRight)
                                                                   (_lhsIsubstitution |-> scheme)
                                                   err = internalError "TypeInferenceOverloading.ag" "n/a" ("could not find type for pattern binding "++show name)
                                               in Just (name, expandPredicates _lhsIorderedTypeSynonyms predicates)
                                            _ -> Nothing
   {-# INLINE rule558 #-}
   rule558 = \ _declPredicates ((_lhsIavailablePredicates) :: Predicates) ->
                                               case _declPredicates of
                                                  Just (_, ps) -> ps ++ _lhsIavailablePredicates
                                                  Nothing      -> _lhsIavailablePredicates
   {-# INLINE rule559 #-}
   rule559 = \ _declPredicates ((_righthandsideIdictionaryEnvironment) :: DictionaryEnvironment) ->
                                                 case _declPredicates of
                                                    Just (n, ps) -> addForDeclaration n ps _righthandsideIdictionaryEnvironment
                                                    Nothing      -> _righthandsideIdictionaryEnvironment
   {-# INLINE rule560 #-}
   rule560 = \ ((_patternIpatVarNames) :: Names) ((_patternIself) :: Pattern) ->
              if isSimplePattern _patternIself
                then ([], _patternIpatVarNames)
                else (_patternIpatVarNames, [])
   {-# INLINE rule561 #-}
   rule561 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ((_patternIenvironment) :: PatternAssumptions) ->
                                                        findCurrentChunk (head (M.keys _patternIenvironment)) _lhsIinheritedBDG
   {-# INLINE rule562 #-}
   rule562 = \ _parentTree ->
     orphanConstraint 1 "right hand side" _parentTree
        []
   {-# INLINE rule563 #-}
   rule563 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Decl _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule564 #-}
   rule564 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ((_righthandsideIinfoTree) :: InfoTree) ->
                                             node _lhsIparentTree _localInfo [_patternIinfoTree, _righthandsideIinfoTree]
   {-# INLINE rule565 #-}
   rule565 = \ _parentTree ->
                                             [_parentTree]
   {-# INLINE rule566 #-}
   rule566 = \ ((_patternIpatVarNames) :: Names) ->
                                             _patternIpatVarNames
   {-# INLINE rule567 #-}
   rule567 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIbeta) :: Tp) ((_patternIelements) ::   [PatternElement]        ) ((_rangeIself) :: Range) ((_righthandsideIfallthrough) :: Bool) ((_righthandsideIpatternMatchWarnings) :: [Warning]) ->
                                                    patternMatchWarnings _lhsIimportEnvironment
                                                                         _lhsIsubstitution
                                                                         _patternIbeta
                                                                         (:[])
                                                                         [(_patternIelements, _righthandsideIfallthrough)]
                                                                         _rangeIself
                                                                         Nothing
                                                                         False
                                                                         []
                                                                         "pattern binding"
                                                                         "="
                                                    ++ _righthandsideIpatternMatchWarnings
   {-# INLINE rule568 #-}
   rule568 = \ ((_righthandsideIcollectInstances) :: [(Name, Instance)]) ->
     _righthandsideIcollectInstances
   {-# INLINE rule569 #-}
   rule569 = \ ((_patternIunboundNames) :: Names) ((_righthandsideIunboundNames) :: Names) ->
     _patternIunboundNames ++ _righthandsideIunboundNames
   {-# INLINE rule570 #-}
   rule570 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ((_righthandsideIself) :: RightHandSide) ->
     Declaration_PatternBinding _rangeIself _patternIself _righthandsideIself
   {-# INLINE rule571 #-}
   rule571 = \ _self ->
     _self
   {-# INLINE rule572 #-}
   rule572 = \ ((_righthandsideIbetaUnique) :: Int) ->
     _righthandsideIbetaUnique
   {-# INLINE rule573 #-}
   rule573 = \ ((_righthandsideIcollectErrors) :: TypeErrors) ->
     _righthandsideIcollectErrors
   {-# INLINE rule574 #-}
   rule574 = \ ((_righthandsideIcollectWarnings) :: Warnings) ->
     _righthandsideIcollectWarnings
   {-# INLINE rule575 #-}
   rule575 = \ ((_righthandsideIcounter) :: Int) ->
     _righthandsideIcounter
   {-# INLINE rule576 #-}
   rule576 = \ ((_righthandsideImatchIO) :: IO ()) ->
     _righthandsideImatchIO
   {-# INLINE rule577 #-}
   rule577 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule578 #-}
   rule578 = \ ((_righthandsideIuniqueChunk) :: Int) ->
     _righthandsideIuniqueChunk
   {-# INLINE rule579 #-}
   rule579 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule580 #-}
   rule580 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule581 #-}
   rule581 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule582 #-}
   rule582 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule583 #-}
   rule583 = \ _parentTree ->
     _parentTree
   {-# INLINE rule584 #-}
   rule584 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule585 #-}
   rule585 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule586 #-}
   rule586 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule587 #-}
   rule587 = \ _betaRight ->
     _betaRight
   {-# INLINE rule588 #-}
   rule588 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule589 #-}
   rule589 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule590 #-}
   rule590 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule591 #-}
   rule591 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule592 #-}
   rule592 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule593 #-}
   rule593 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule594 #-}
   rule594 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule595 #-}
   rule595 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule596 #-}
   rule596 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule597 #-}
   rule597 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule598 #-}
   rule598 = \ _parentTree ->
     _parentTree
   {-# INLINE rule599 #-}
   rule599 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule600 #-}
   rule600 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule601 #-}
   rule601 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule602 #-}
   rule602 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_TypeSignature #-}
sem_Declaration_TypeSignature :: T_Range  -> T_Names  -> T_Type  -> T_Declaration 
sem_Declaration_TypeSignature arg_range_ arg_names_ arg_type_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _namesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_names_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Names_vOut115 _namesIself) = inv_Names_s116 _namesX116 (T_Names_vIn115 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule603 _lhsItypeSignatures _namesIself _typeScheme
         _typeScheme = rule604 _typeIself
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule605  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule606  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule607  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule608  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule609  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule610  ()
         _self = rule611 _namesIself _rangeIself _typeIself
         _lhsOself :: Declaration
         _lhsOself = rule612 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule613 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule614 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule615 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule616 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule617 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule618 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule619 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule620 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule621 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule603 #-}
   rule603 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ((_namesIself) :: Names) _typeScheme ->
                               _lhsItypeSignatures `M.union` (M.fromList [ (name, _typeScheme) | name <- _namesIself ])
   {-# INLINE rule604 #-}
   rule604 = \ ((_typeIself) :: Type) ->
                               makeTpSchemeFromType _typeIself
   {-# INLINE rule605 #-}
   rule605 = \  (_ :: ()) ->
                                       []
   {-# INLINE rule606 #-}
   rule606 = \  (_ :: ()) ->
     []
   {-# INLINE rule607 #-}
   rule607 = \  (_ :: ()) ->
     []
   {-# INLINE rule608 #-}
   rule608 = \  (_ :: ()) ->
     []
   {-# INLINE rule609 #-}
   rule609 = \  (_ :: ()) ->
     []
   {-# INLINE rule610 #-}
   rule610 = \  (_ :: ()) ->
     []
   {-# INLINE rule611 #-}
   rule611 = \ ((_namesIself) :: Names) ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
     Declaration_TypeSignature _rangeIself _namesIself _typeIself
   {-# INLINE rule612 #-}
   rule612 = \ _self ->
     _self
   {-# INLINE rule613 #-}
   rule613 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule614 #-}
   rule614 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule615 #-}
   rule615 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule616 #-}
   rule616 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule617 #-}
   rule617 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule618 #-}
   rule618 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule619 #-}
   rule619 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule620 #-}
   rule620 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule621 #-}
   rule621 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Fixity #-}
sem_Declaration_Fixity :: T_Range  -> T_Fixity  -> T_MaybeInt  -> T_Names  -> T_Declaration 
sem_Declaration_Fixity arg_range_ arg_fixity_ arg_priority_ arg_operators_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _fixityX53 = Control.Monad.Identity.runIdentity (attach_T_Fixity (arg_fixity_))
         _priorityX101 = Control.Monad.Identity.runIdentity (attach_T_MaybeInt (arg_priority_))
         _operatorsX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_operators_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Fixity_vOut52 _fixityIself) = inv_Fixity_s53 _fixityX53 (T_Fixity_vIn52 )
         (T_MaybeInt_vOut100 _priorityIself) = inv_MaybeInt_s101 _priorityX101 (T_MaybeInt_vIn100 )
         (T_Names_vOut115 _operatorsIself) = inv_Names_s116 _operatorsX116 (T_Names_vIn115 )
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule622  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule623  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule624  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule625  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule626  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule627  ()
         _self = rule628 _fixityIself _operatorsIself _priorityIself _rangeIself
         _lhsOself :: Declaration
         _lhsOself = rule629 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule630 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule631 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule632 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule633 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule634 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule635 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule636 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule637 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule638 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule639 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule622 #-}
   rule622 = \  (_ :: ()) ->
                                       []
   {-# INLINE rule623 #-}
   rule623 = \  (_ :: ()) ->
     []
   {-# INLINE rule624 #-}
   rule624 = \  (_ :: ()) ->
     []
   {-# INLINE rule625 #-}
   rule625 = \  (_ :: ()) ->
     []
   {-# INLINE rule626 #-}
   rule626 = \  (_ :: ()) ->
     []
   {-# INLINE rule627 #-}
   rule627 = \  (_ :: ()) ->
     []
   {-# INLINE rule628 #-}
   rule628 = \ ((_fixityIself) :: Fixity) ((_operatorsIself) :: Names) ((_priorityIself) :: MaybeInt) ((_rangeIself) :: Range) ->
     Declaration_Fixity _rangeIself _fixityIself _priorityIself _operatorsIself
   {-# INLINE rule629 #-}
   rule629 = \ _self ->
     _self
   {-# INLINE rule630 #-}
   rule630 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule631 #-}
   rule631 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule632 #-}
   rule632 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule633 #-}
   rule633 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule634 #-}
   rule634 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule635 #-}
   rule635 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule636 #-}
   rule636 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule637 #-}
   rule637 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule638 #-}
   rule638 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule639 #-}
   rule639 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Declaration_Empty #-}
sem_Declaration_Empty :: T_Range  -> T_Declaration 
sem_Declaration_Empty arg_range_ = T_Declaration (return st29) where
   {-# NOINLINE st29 #-}
   st29 = let
      v28 :: T_Declaration_v28 
      v28 = \ (T_Declaration_vIn28 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule640  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule641  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule642  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule643  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule644  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule645  ()
         _self = rule646 _rangeIself
         _lhsOself :: Declaration
         _lhsOself = rule647 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule648 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule649 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule650 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule651 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule652 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule653 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule654 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule655 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule656 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule657 _lhsIuniqueChunk
         __result_ = T_Declaration_vOut28 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declaration_s29 v28
   {-# INLINE rule640 #-}
   rule640 = \  (_ :: ()) ->
                                       []
   {-# INLINE rule641 #-}
   rule641 = \  (_ :: ()) ->
     []
   {-# INLINE rule642 #-}
   rule642 = \  (_ :: ()) ->
     []
   {-# INLINE rule643 #-}
   rule643 = \  (_ :: ()) ->
     []
   {-# INLINE rule644 #-}
   rule644 = \  (_ :: ()) ->
     []
   {-# INLINE rule645 #-}
   rule645 = \  (_ :: ()) ->
     []
   {-# INLINE rule646 #-}
   rule646 = \ ((_rangeIself) :: Range) ->
     Declaration_Empty _rangeIself
   {-# INLINE rule647 #-}
   rule647 = \ _self ->
     _self
   {-# INLINE rule648 #-}
   rule648 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule649 #-}
   rule649 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule650 #-}
   rule650 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule651 #-}
   rule651 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule652 #-}
   rule652 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule653 #-}
   rule653 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule654 #-}
   rule654 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule655 #-}
   rule655 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule656 #-}
   rule656 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule657 #-}
   rule657 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- Declarations ------------------------------------------------
-- wrapper
data Inh_Declarations  = Inh_Declarations { allPatterns_Inh_Declarations :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Declarations :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Declarations :: (Predicates), betaUnique_Inh_Declarations :: (Int), bindingGroups_Inh_Declarations :: (BindingGroups), classEnvironment_Inh_Declarations :: (ClassEnvironment), collectErrors_Inh_Declarations :: (TypeErrors), collectWarnings_Inh_Declarations :: (Warnings), counter_Inh_Declarations :: (Int), currentChunk_Inh_Declarations :: (Int), dictionaryEnvironment_Inh_Declarations :: (DictionaryEnvironment), importEnvironment_Inh_Declarations :: (ImportEnvironment), inheritedBDG_Inh_Declarations :: (InheritedBDG), matchIO_Inh_Declarations :: (IO ()), monos_Inh_Declarations :: (Monos), namesInScope_Inh_Declarations :: (Names), orderedTypeSynonyms_Inh_Declarations :: (OrderedTypeSynonyms), parentTree_Inh_Declarations :: (InfoTree), patternMatchWarnings_Inh_Declarations :: ([Warning]), substitution_Inh_Declarations :: (FixpointSubstitution), typeSignatures_Inh_Declarations :: (TypeEnvironment), typeschemeMap_Inh_Declarations :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Declarations :: (Int) }
data Syn_Declarations  = Syn_Declarations { betaUnique_Syn_Declarations :: (Int), bindingGroups_Syn_Declarations :: (BindingGroups), collectErrors_Syn_Declarations :: (TypeErrors), collectInstances_Syn_Declarations :: ([(Name, Instance)]), collectWarnings_Syn_Declarations :: (Warnings), counter_Syn_Declarations :: (Int), declVarNames_Syn_Declarations :: (Names), dictionaryEnvironment_Syn_Declarations :: (DictionaryEnvironment), infoTrees_Syn_Declarations :: (InfoTrees), matchIO_Syn_Declarations :: (IO ()), patternMatchWarnings_Syn_Declarations :: ([Warning]), restrictedNames_Syn_Declarations :: (Names), self_Syn_Declarations :: (Declarations), simplePatNames_Syn_Declarations :: (Names), typeSignatures_Syn_Declarations :: (TypeEnvironment), unboundNames_Syn_Declarations :: (Names), uniqueChunk_Syn_Declarations :: (Int) }
{-# INLINABLE wrap_Declarations #-}
wrap_Declarations :: T_Declarations  -> Inh_Declarations  -> (Syn_Declarations )
wrap_Declarations (T_Declarations act) (Inh_Declarations _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Declarations_vIn31 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk
        (T_Declarations_vOut31 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_Declarations_s32 sem arg)
        return (Syn_Declarations _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_Declarations #-}
sem_Declarations :: Declarations  -> T_Declarations 
sem_Declarations list = Prelude.foldr sem_Declarations_Cons sem_Declarations_Nil (Prelude.map sem_Declaration list)

-- semantic domain
newtype T_Declarations  = T_Declarations {
                                         attach_T_Declarations :: Identity (T_Declarations_s32 )
                                         }
newtype T_Declarations_s32  = C_Declarations_s32 {
                                                 inv_Declarations_s32 :: (T_Declarations_v31 )
                                                 }
data T_Declarations_s33  = C_Declarations_s33
type T_Declarations_v31  = (T_Declarations_vIn31 ) -> (T_Declarations_vOut31 )
data T_Declarations_vIn31  = T_Declarations_vIn31 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (BindingGroups) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (InheritedBDG) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (TypeEnvironment) (M.Map Int (Scheme Predicates)) (Int)
data T_Declarations_vOut31  = T_Declarations_vOut31 (Int) (BindingGroups) (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (Names) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Warning]) (Names) (Declarations) (Names) (TypeEnvironment) (Names) (Int)
{-# NOINLINE sem_Declarations_Cons #-}
sem_Declarations_Cons :: T_Declaration  -> T_Declarations  -> T_Declarations 
sem_Declarations_Cons arg_hd_ arg_tl_ = T_Declarations (return st32) where
   {-# NOINLINE st32 #-}
   st32 = let
      v31 :: T_Declarations_v31 
      v31 = \ (T_Declarations_vIn31 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _hdX29 = Control.Monad.Identity.runIdentity (attach_T_Declaration (arg_hd_))
         _tlX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_tl_))
         (T_Declaration_vOut28 _hdIbetaUnique _hdIbindingGroups _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIcounter _hdIdeclVarNames _hdIdictionaryEnvironment _hdIinfoTrees _hdImatchIO _hdIpatternMatchWarnings _hdIrestrictedNames _hdIself _hdIsimplePatNames _hdItypeSignatures _hdIunboundNames _hdIuniqueChunk) = inv_Declaration_s29 _hdX29 (T_Declaration_vIn28 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaUnique _hdObindingGroups _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOinheritedBDG _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeSignatures _hdOtypeschemeMap _hdOuniqueChunk)
         (T_Declarations_vOut31 _tlIbetaUnique _tlIbindingGroups _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIcounter _tlIdeclVarNames _tlIdictionaryEnvironment _tlIinfoTrees _tlImatchIO _tlIpatternMatchWarnings _tlIrestrictedNames _tlIself _tlIsimplePatNames _tlItypeSignatures _tlIunboundNames _tlIuniqueChunk) = inv_Declarations_s32 _tlX32 (T_Declarations_vIn31 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaUnique _tlObindingGroups _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOinheritedBDG _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeSignatures _tlOtypeschemeMap _tlOuniqueChunk)
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule658 _hdIinfoTrees _tlIinfoTrees
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule659 _hdIcollectInstances _tlIcollectInstances
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule660 _hdIdeclVarNames _tlIdeclVarNames
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule661 _hdIrestrictedNames _tlIrestrictedNames
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule662 _hdIsimplePatNames _tlIsimplePatNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule663 _hdIunboundNames _tlIunboundNames
         _self = rule664 _hdIself _tlIself
         _lhsOself :: Declarations
         _lhsOself = rule665 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule666 _tlIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule667 _tlIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule668 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule669 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule670 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule671 _tlIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule672 _tlImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule673 _tlIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule674 _tlItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule675 _tlIuniqueChunk
         _hdOallPatterns = rule676 _lhsIallPatterns
         _hdOallTypeSchemes = rule677 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule678 _lhsIavailablePredicates
         _hdObetaUnique = rule679 _lhsIbetaUnique
         _hdObindingGroups = rule680 _lhsIbindingGroups
         _hdOclassEnvironment = rule681 _lhsIclassEnvironment
         _hdOcollectErrors = rule682 _lhsIcollectErrors
         _hdOcollectWarnings = rule683 _lhsIcollectWarnings
         _hdOcounter = rule684 _lhsIcounter
         _hdOcurrentChunk = rule685 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule686 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule687 _lhsIimportEnvironment
         _hdOinheritedBDG = rule688 _lhsIinheritedBDG
         _hdOmatchIO = rule689 _lhsImatchIO
         _hdOmonos = rule690 _lhsImonos
         _hdOnamesInScope = rule691 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule692 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule693 _lhsIparentTree
         _hdOpatternMatchWarnings = rule694 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule695 _lhsIsubstitution
         _hdOtypeSignatures = rule696 _lhsItypeSignatures
         _hdOtypeschemeMap = rule697 _lhsItypeschemeMap
         _hdOuniqueChunk = rule698 _lhsIuniqueChunk
         _tlOallPatterns = rule699 _lhsIallPatterns
         _tlOallTypeSchemes = rule700 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule701 _lhsIavailablePredicates
         _tlObetaUnique = rule702 _hdIbetaUnique
         _tlObindingGroups = rule703 _hdIbindingGroups
         _tlOclassEnvironment = rule704 _lhsIclassEnvironment
         _tlOcollectErrors = rule705 _hdIcollectErrors
         _tlOcollectWarnings = rule706 _hdIcollectWarnings
         _tlOcounter = rule707 _hdIcounter
         _tlOcurrentChunk = rule708 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule709 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule710 _lhsIimportEnvironment
         _tlOinheritedBDG = rule711 _lhsIinheritedBDG
         _tlOmatchIO = rule712 _hdImatchIO
         _tlOmonos = rule713 _lhsImonos
         _tlOnamesInScope = rule714 _lhsInamesInScope
         _tlOorderedTypeSynonyms = rule715 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule716 _lhsIparentTree
         _tlOpatternMatchWarnings = rule717 _hdIpatternMatchWarnings
         _tlOsubstitution = rule718 _lhsIsubstitution
         _tlOtypeSignatures = rule719 _hdItypeSignatures
         _tlOtypeschemeMap = rule720 _lhsItypeschemeMap
         _tlOuniqueChunk = rule721 _hdIuniqueChunk
         __result_ = T_Declarations_vOut31 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declarations_s32 v31
   {-# INLINE rule658 #-}
   rule658 = \ ((_hdIinfoTrees) :: InfoTrees) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTrees ++ _tlIinfoTrees
   {-# INLINE rule659 #-}
   rule659 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule660 #-}
   rule660 = \ ((_hdIdeclVarNames) :: Names) ((_tlIdeclVarNames) :: Names) ->
     _hdIdeclVarNames ++ _tlIdeclVarNames
   {-# INLINE rule661 #-}
   rule661 = \ ((_hdIrestrictedNames) :: Names) ((_tlIrestrictedNames) :: Names) ->
     _hdIrestrictedNames  ++  _tlIrestrictedNames
   {-# INLINE rule662 #-}
   rule662 = \ ((_hdIsimplePatNames) :: Names) ((_tlIsimplePatNames) :: Names) ->
     _hdIsimplePatNames  ++  _tlIsimplePatNames
   {-# INLINE rule663 #-}
   rule663 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule664 #-}
   rule664 = \ ((_hdIself) :: Declaration) ((_tlIself) :: Declarations) ->
     (:) _hdIself _tlIself
   {-# INLINE rule665 #-}
   rule665 = \ _self ->
     _self
   {-# INLINE rule666 #-}
   rule666 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule667 #-}
   rule667 = \ ((_tlIbindingGroups) :: BindingGroups) ->
     _tlIbindingGroups
   {-# INLINE rule668 #-}
   rule668 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule669 #-}
   rule669 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule670 #-}
   rule670 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule671 #-}
   rule671 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule672 #-}
   rule672 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule673 #-}
   rule673 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule674 #-}
   rule674 = \ ((_tlItypeSignatures) :: TypeEnvironment) ->
     _tlItypeSignatures
   {-# INLINE rule675 #-}
   rule675 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule676 #-}
   rule676 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule677 #-}
   rule677 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule678 #-}
   rule678 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule679 #-}
   rule679 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule680 #-}
   rule680 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule681 #-}
   rule681 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule682 #-}
   rule682 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule683 #-}
   rule683 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule684 #-}
   rule684 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule685 #-}
   rule685 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule686 #-}
   rule686 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule687 #-}
   rule687 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule688 #-}
   rule688 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ->
     _lhsIinheritedBDG
   {-# INLINE rule689 #-}
   rule689 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule690 #-}
   rule690 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule691 #-}
   rule691 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule692 #-}
   rule692 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule693 #-}
   rule693 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule694 #-}
   rule694 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule695 #-}
   rule695 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule696 #-}
   rule696 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule697 #-}
   rule697 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule698 #-}
   rule698 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule699 #-}
   rule699 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule700 #-}
   rule700 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule701 #-}
   rule701 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule702 #-}
   rule702 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule703 #-}
   rule703 = \ ((_hdIbindingGroups) :: BindingGroups) ->
     _hdIbindingGroups
   {-# INLINE rule704 #-}
   rule704 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule705 #-}
   rule705 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule706 #-}
   rule706 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule707 #-}
   rule707 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule708 #-}
   rule708 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule709 #-}
   rule709 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule710 #-}
   rule710 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule711 #-}
   rule711 = \ ((_lhsIinheritedBDG) :: InheritedBDG) ->
     _lhsIinheritedBDG
   {-# INLINE rule712 #-}
   rule712 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule713 #-}
   rule713 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule714 #-}
   rule714 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule715 #-}
   rule715 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule716 #-}
   rule716 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule717 #-}
   rule717 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule718 #-}
   rule718 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule719 #-}
   rule719 = \ ((_hdItypeSignatures) :: TypeEnvironment) ->
     _hdItypeSignatures
   {-# INLINE rule720 #-}
   rule720 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule721 #-}
   rule721 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
{-# NOINLINE sem_Declarations_Nil #-}
sem_Declarations_Nil ::  T_Declarations 
sem_Declarations_Nil  = T_Declarations (return st32) where
   {-# NOINLINE st32 #-}
   st32 = let
      v31 :: T_Declarations_v31 
      v31 = \ (T_Declarations_vIn31 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIbindingGroups _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsIinheritedBDG _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeSignatures _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule722  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule723  ()
         _lhsOdeclVarNames :: Names
         _lhsOdeclVarNames = rule724  ()
         _lhsOrestrictedNames :: Names
         _lhsOrestrictedNames = rule725  ()
         _lhsOsimplePatNames :: Names
         _lhsOsimplePatNames = rule726  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule727  ()
         _self = rule728  ()
         _lhsOself :: Declarations
         _lhsOself = rule729 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule730 _lhsIbetaUnique
         _lhsObindingGroups :: BindingGroups
         _lhsObindingGroups = rule731 _lhsIbindingGroups
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule732 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule733 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule734 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule735 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule736 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule737 _lhsIpatternMatchWarnings
         _lhsOtypeSignatures :: TypeEnvironment
         _lhsOtypeSignatures = rule738 _lhsItypeSignatures
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule739 _lhsIuniqueChunk
         __result_ = T_Declarations_vOut31 _lhsObetaUnique _lhsObindingGroups _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdeclVarNames _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrestrictedNames _lhsOself _lhsOsimplePatNames _lhsOtypeSignatures _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_Declarations_s32 v31
   {-# INLINE rule722 #-}
   rule722 = \  (_ :: ()) ->
                               []
   {-# INLINE rule723 #-}
   rule723 = \  (_ :: ()) ->
     []
   {-# INLINE rule724 #-}
   rule724 = \  (_ :: ()) ->
     []
   {-# INLINE rule725 #-}
   rule725 = \  (_ :: ()) ->
     []
   {-# INLINE rule726 #-}
   rule726 = \  (_ :: ()) ->
     []
   {-# INLINE rule727 #-}
   rule727 = \  (_ :: ()) ->
     []
   {-# INLINE rule728 #-}
   rule728 = \  (_ :: ()) ->
     []
   {-# INLINE rule729 #-}
   rule729 = \ _self ->
     _self
   {-# INLINE rule730 #-}
   rule730 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule731 #-}
   rule731 = \ ((_lhsIbindingGroups) :: BindingGroups) ->
     _lhsIbindingGroups
   {-# INLINE rule732 #-}
   rule732 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule733 #-}
   rule733 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule734 #-}
   rule734 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule735 #-}
   rule735 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule736 #-}
   rule736 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule737 #-}
   rule737 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule738 #-}
   rule738 = \ ((_lhsItypeSignatures) :: TypeEnvironment) ->
     _lhsItypeSignatures
   {-# INLINE rule739 #-}
   rule739 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- Export ------------------------------------------------------
-- wrapper
data Inh_Export  = Inh_Export {  }
data Syn_Export  = Syn_Export { self_Syn_Export :: (Export) }
{-# INLINABLE wrap_Export #-}
wrap_Export :: T_Export  -> Inh_Export  -> (Syn_Export )
wrap_Export (T_Export act) (Inh_Export ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Export_vIn34 
        (T_Export_vOut34 _lhsOself) <- return (inv_Export_s35 sem arg)
        return (Syn_Export _lhsOself)
   )

-- cata
{-# NOINLINE sem_Export #-}
sem_Export :: Export  -> T_Export 
sem_Export ( Export_Variable range_ name_ ) = sem_Export_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Export ( Export_TypeOrClass range_ name_ names_ ) = sem_Export_TypeOrClass ( sem_Range range_ ) ( sem_Name name_ ) ( sem_MaybeNames names_ )
sem_Export ( Export_TypeOrClassComplete range_ name_ ) = sem_Export_TypeOrClassComplete ( sem_Range range_ ) ( sem_Name name_ )
sem_Export ( Export_Module range_ name_ ) = sem_Export_Module ( sem_Range range_ ) ( sem_Name name_ )

-- semantic domain
newtype T_Export  = T_Export {
                             attach_T_Export :: Identity (T_Export_s35 )
                             }
newtype T_Export_s35  = C_Export_s35 {
                                     inv_Export_s35 :: (T_Export_v34 )
                                     }
data T_Export_s36  = C_Export_s36
type T_Export_v34  = (T_Export_vIn34 ) -> (T_Export_vOut34 )
data T_Export_vIn34  = T_Export_vIn34 
data T_Export_vOut34  = T_Export_vOut34 (Export)
{-# NOINLINE sem_Export_Variable #-}
sem_Export_Variable :: T_Range  -> T_Name  -> T_Export 
sem_Export_Variable arg_range_ arg_name_ = T_Export (return st35) where
   {-# NOINLINE st35 #-}
   st35 = let
      v34 :: T_Export_v34 
      v34 = \ (T_Export_vIn34 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule740 _nameIself _rangeIself
         _lhsOself :: Export
         _lhsOself = rule741 _self
         __result_ = T_Export_vOut34 _lhsOself
         in __result_ )
     in C_Export_s35 v34
   {-# INLINE rule740 #-}
   rule740 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Export_Variable _rangeIself _nameIself
   {-# INLINE rule741 #-}
   rule741 = \ _self ->
     _self
{-# NOINLINE sem_Export_TypeOrClass #-}
sem_Export_TypeOrClass :: T_Range  -> T_Name  -> T_MaybeNames  -> T_Export 
sem_Export_TypeOrClass arg_range_ arg_name_ arg_names_ = T_Export (return st35) where
   {-# NOINLINE st35 #-}
   st35 = let
      v34 :: T_Export_v34 
      v34 = \ (T_Export_vIn34 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _namesX107 = Control.Monad.Identity.runIdentity (attach_T_MaybeNames (arg_names_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_MaybeNames_vOut106 _namesIself) = inv_MaybeNames_s107 _namesX107 (T_MaybeNames_vIn106 )
         _self = rule742 _nameIself _namesIself _rangeIself
         _lhsOself :: Export
         _lhsOself = rule743 _self
         __result_ = T_Export_vOut34 _lhsOself
         in __result_ )
     in C_Export_s35 v34
   {-# INLINE rule742 #-}
   rule742 = \ ((_nameIself) :: Name) ((_namesIself) :: MaybeNames) ((_rangeIself) :: Range) ->
     Export_TypeOrClass _rangeIself _nameIself _namesIself
   {-# INLINE rule743 #-}
   rule743 = \ _self ->
     _self
{-# NOINLINE sem_Export_TypeOrClassComplete #-}
sem_Export_TypeOrClassComplete :: T_Range  -> T_Name  -> T_Export 
sem_Export_TypeOrClassComplete arg_range_ arg_name_ = T_Export (return st35) where
   {-# NOINLINE st35 #-}
   st35 = let
      v34 :: T_Export_v34 
      v34 = \ (T_Export_vIn34 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule744 _nameIself _rangeIself
         _lhsOself :: Export
         _lhsOself = rule745 _self
         __result_ = T_Export_vOut34 _lhsOself
         in __result_ )
     in C_Export_s35 v34
   {-# INLINE rule744 #-}
   rule744 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Export_TypeOrClassComplete _rangeIself _nameIself
   {-# INLINE rule745 #-}
   rule745 = \ _self ->
     _self
{-# NOINLINE sem_Export_Module #-}
sem_Export_Module :: T_Range  -> T_Name  -> T_Export 
sem_Export_Module arg_range_ arg_name_ = T_Export (return st35) where
   {-# NOINLINE st35 #-}
   st35 = let
      v34 :: T_Export_v34 
      v34 = \ (T_Export_vIn34 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule746 _nameIself _rangeIself
         _lhsOself :: Export
         _lhsOself = rule747 _self
         __result_ = T_Export_vOut34 _lhsOself
         in __result_ )
     in C_Export_s35 v34
   {-# INLINE rule746 #-}
   rule746 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Export_Module _rangeIself _nameIself
   {-# INLINE rule747 #-}
   rule747 = \ _self ->
     _self

-- Exports -----------------------------------------------------
-- wrapper
data Inh_Exports  = Inh_Exports {  }
data Syn_Exports  = Syn_Exports { self_Syn_Exports :: (Exports) }
{-# INLINABLE wrap_Exports #-}
wrap_Exports :: T_Exports  -> Inh_Exports  -> (Syn_Exports )
wrap_Exports (T_Exports act) (Inh_Exports ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Exports_vIn37 
        (T_Exports_vOut37 _lhsOself) <- return (inv_Exports_s38 sem arg)
        return (Syn_Exports _lhsOself)
   )

-- cata
{-# NOINLINE sem_Exports #-}
sem_Exports :: Exports  -> T_Exports 
sem_Exports list = Prelude.foldr sem_Exports_Cons sem_Exports_Nil (Prelude.map sem_Export list)

-- semantic domain
newtype T_Exports  = T_Exports {
                               attach_T_Exports :: Identity (T_Exports_s38 )
                               }
newtype T_Exports_s38  = C_Exports_s38 {
                                       inv_Exports_s38 :: (T_Exports_v37 )
                                       }
data T_Exports_s39  = C_Exports_s39
type T_Exports_v37  = (T_Exports_vIn37 ) -> (T_Exports_vOut37 )
data T_Exports_vIn37  = T_Exports_vIn37 
data T_Exports_vOut37  = T_Exports_vOut37 (Exports)
{-# NOINLINE sem_Exports_Cons #-}
sem_Exports_Cons :: T_Export  -> T_Exports  -> T_Exports 
sem_Exports_Cons arg_hd_ arg_tl_ = T_Exports (return st38) where
   {-# NOINLINE st38 #-}
   st38 = let
      v37 :: T_Exports_v37 
      v37 = \ (T_Exports_vIn37 ) -> ( let
         _hdX35 = Control.Monad.Identity.runIdentity (attach_T_Export (arg_hd_))
         _tlX38 = Control.Monad.Identity.runIdentity (attach_T_Exports (arg_tl_))
         (T_Export_vOut34 _hdIself) = inv_Export_s35 _hdX35 (T_Export_vIn34 )
         (T_Exports_vOut37 _tlIself) = inv_Exports_s38 _tlX38 (T_Exports_vIn37 )
         _self = rule748 _hdIself _tlIself
         _lhsOself :: Exports
         _lhsOself = rule749 _self
         __result_ = T_Exports_vOut37 _lhsOself
         in __result_ )
     in C_Exports_s38 v37
   {-# INLINE rule748 #-}
   rule748 = \ ((_hdIself) :: Export) ((_tlIself) :: Exports) ->
     (:) _hdIself _tlIself
   {-# INLINE rule749 #-}
   rule749 = \ _self ->
     _self
{-# NOINLINE sem_Exports_Nil #-}
sem_Exports_Nil ::  T_Exports 
sem_Exports_Nil  = T_Exports (return st38) where
   {-# NOINLINE st38 #-}
   st38 = let
      v37 :: T_Exports_v37 
      v37 = \ (T_Exports_vIn37 ) -> ( let
         _self = rule750  ()
         _lhsOself :: Exports
         _lhsOself = rule751 _self
         __result_ = T_Exports_vOut37 _lhsOself
         in __result_ )
     in C_Exports_s38 v37
   {-# INLINE rule750 #-}
   rule750 = \  (_ :: ()) ->
     []
   {-# INLINE rule751 #-}
   rule751 = \ _self ->
     _self

-- Expression --------------------------------------------------
-- wrapper
data Inh_Expression  = Inh_Expression { allPatterns_Inh_Expression :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Expression :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Expression :: (Predicates), betaUnique_Inh_Expression :: (Int), classEnvironment_Inh_Expression :: (ClassEnvironment), collectErrors_Inh_Expression :: (TypeErrors), collectWarnings_Inh_Expression :: (Warnings), counter_Inh_Expression :: (Int), currentChunk_Inh_Expression :: (Int), dictionaryEnvironment_Inh_Expression :: (DictionaryEnvironment), importEnvironment_Inh_Expression :: (ImportEnvironment), matchIO_Inh_Expression :: (IO ()), monos_Inh_Expression :: (Monos), namesInScope_Inh_Expression :: (Names), orderedTypeSynonyms_Inh_Expression :: (OrderedTypeSynonyms), parentTree_Inh_Expression :: (InfoTree), patternMatchWarnings_Inh_Expression :: ([Warning]), substitution_Inh_Expression :: (FixpointSubstitution), tryPatterns_Inh_Expression :: ([(Expression     , [String])]), typeschemeMap_Inh_Expression :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Expression :: (Int), uniqueSecondRound_Inh_Expression :: (Int) }
data Syn_Expression  = Syn_Expression { assumptions_Syn_Expression :: (Assumptions), beta_Syn_Expression :: (Tp), betaUnique_Syn_Expression :: (Int), collectErrors_Syn_Expression :: (TypeErrors), collectInstances_Syn_Expression :: ([(Name, Instance)]), collectWarnings_Syn_Expression :: (Warnings), constraints_Syn_Expression :: (ConstraintSet), counter_Syn_Expression :: (Int), dictionaryEnvironment_Syn_Expression :: (DictionaryEnvironment), infoTree_Syn_Expression :: (InfoTree), matchIO_Syn_Expression :: (IO ()), matches_Syn_Expression :: ([Maybe MetaVariableTable]), patternMatchWarnings_Syn_Expression :: ([Warning]), self_Syn_Expression :: (Expression), unboundNames_Syn_Expression :: (Names), uniqueChunk_Syn_Expression :: (Int), uniqueSecondRound_Syn_Expression :: (Int) }
{-# INLINABLE wrap_Expression #-}
wrap_Expression :: T_Expression  -> Inh_Expression  -> (Syn_Expression )
wrap_Expression (T_Expression act) (Inh_Expression _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Expression_s41 sem arg)
        return (Syn_Expression _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_Expression #-}
sem_Expression :: Expression  -> T_Expression 
sem_Expression ( Expression_Hole range_ id_ ) = sem_Expression_Hole ( sem_Range range_ ) id_
sem_Expression ( Expression_Feedback range_ feedback_ expression_ ) = sem_Expression_Feedback ( sem_Range range_ ) feedback_ ( sem_Expression expression_ )
sem_Expression ( Expression_MustUse range_ expression_ ) = sem_Expression_MustUse ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_Literal range_ literal_ ) = sem_Expression_Literal ( sem_Range range_ ) ( sem_Literal literal_ )
sem_Expression ( Expression_Variable range_ name_ ) = sem_Expression_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Expression ( Expression_Constructor range_ name_ ) = sem_Expression_Constructor ( sem_Range range_ ) ( sem_Name name_ )
sem_Expression ( Expression_Parenthesized range_ expression_ ) = sem_Expression_Parenthesized ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_NormalApplication range_ function_ arguments_ ) = sem_Expression_NormalApplication ( sem_Range range_ ) ( sem_Expression function_ ) ( sem_Expressions arguments_ )
sem_Expression ( Expression_InfixApplication range_ leftExpression_ operator_ rightExpression_ ) = sem_Expression_InfixApplication ( sem_Range range_ ) ( sem_MaybeExpression leftExpression_ ) ( sem_Expression operator_ ) ( sem_MaybeExpression rightExpression_ )
sem_Expression ( Expression_If range_ guardExpression_ thenExpression_ elseExpression_ ) = sem_Expression_If ( sem_Range range_ ) ( sem_Expression guardExpression_ ) ( sem_Expression thenExpression_ ) ( sem_Expression elseExpression_ )
sem_Expression ( Expression_Lambda range_ patterns_ expression_ ) = sem_Expression_Lambda ( sem_Range range_ ) ( sem_Patterns patterns_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_Case range_ expression_ alternatives_ ) = sem_Expression_Case ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_Alternatives alternatives_ )
sem_Expression ( Expression_Let range_ declarations_ expression_ ) = sem_Expression_Let ( sem_Range range_ ) ( sem_Declarations declarations_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_Do range_ statements_ ) = sem_Expression_Do ( sem_Range range_ ) ( sem_Statements statements_ )
sem_Expression ( Expression_List range_ expressions_ ) = sem_Expression_List ( sem_Range range_ ) ( sem_Expressions expressions_ )
sem_Expression ( Expression_Tuple range_ expressions_ ) = sem_Expression_Tuple ( sem_Range range_ ) ( sem_Expressions expressions_ )
sem_Expression ( Expression_Comprehension range_ expression_ qualifiers_ ) = sem_Expression_Comprehension ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_Qualifiers qualifiers_ )
sem_Expression ( Expression_Typed range_ expression_ type_ ) = sem_Expression_Typed ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_Type type_ )
sem_Expression ( Expression_RecordConstruction range_ name_ recordExpressionBindings_ ) = sem_Expression_RecordConstruction ( sem_Range range_ ) ( sem_Name name_ ) ( sem_RecordExpressionBindings recordExpressionBindings_ )
sem_Expression ( Expression_RecordUpdate range_ expression_ recordExpressionBindings_ ) = sem_Expression_RecordUpdate ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_RecordExpressionBindings recordExpressionBindings_ )
sem_Expression ( Expression_Enum range_ from_ then_ to_ ) = sem_Expression_Enum ( sem_Range range_ ) ( sem_Expression from_ ) ( sem_MaybeExpression then_ ) ( sem_MaybeExpression to_ )
sem_Expression ( Expression_Negate range_ expression_ ) = sem_Expression_Negate ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Expression ( Expression_NegateFloat range_ expression_ ) = sem_Expression_NegateFloat ( sem_Range range_ ) ( sem_Expression expression_ )

-- semantic domain
newtype T_Expression  = T_Expression {
                                     attach_T_Expression :: Identity (T_Expression_s41 )
                                     }
newtype T_Expression_s41  = C_Expression_s41 {
                                             inv_Expression_s41 :: (T_Expression_v40 )
                                             }
data T_Expression_s42  = C_Expression_s42
type T_Expression_v40  = (T_Expression_vIn40 ) -> (T_Expression_vOut40 )
data T_Expression_vIn40  = T_Expression_vIn40 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) ([(Expression     , [String])]) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_Expression_vOut40  = T_Expression_vOut40 (Assumptions) (Tp) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTree) (IO ()) ([Maybe MetaVariableTable]) ([Warning]) (Expression) (Names) (Int) (Int)
{-# NOINLINE sem_Expression_Hole #-}
sem_Expression_Hole :: T_Range  -> (Integer) -> T_Expression 
sem_Expression_Hole arg_range_ arg_id_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule752 _lhsIbetaUnique
         _assumptions = rule753  ()
         _constraints = rule754  ()
         _beta = rule755 _lhsIbetaUnique
         _localInfo = rule756 _beta _lhsImonos _self
         _parentTree = rule757 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule758 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule759 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _localInfo
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule760  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule761  ()
         _self = rule762 _rangeIself arg_id_
         _lhsOself :: Expression
         _lhsOself = rule763 _self
         _lhsObeta :: Tp
         _lhsObeta = rule764 _beta
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule765 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule766 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule767 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule768 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule769 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule770 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule771 _lhsIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule752 #-}
   rule752 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule753 #-}
   rule753 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule754 #-}
   rule754 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule755 #-}
   rule755 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule756 #-}
   rule756 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule757 #-}
   rule757 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule758 #-}
   rule758 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule759 #-}
   rule759 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) ((_lhsIuniqueSecondRound) :: Int) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in match0 infoTuple _lhsIuniqueSecondRound
                      (const Nothing)
                      _lhsItryPatterns _lhsIallPatterns
                      []
   {-# INLINE rule760 #-}
   rule760 = \  (_ :: ()) ->
     []
   {-# INLINE rule761 #-}
   rule761 = \  (_ :: ()) ->
     []
   {-# INLINE rule762 #-}
   rule762 = \ ((_rangeIself) :: Range) id_ ->
     Expression_Hole _rangeIself id_
   {-# INLINE rule763 #-}
   rule763 = \ _self ->
     _self
   {-# INLINE rule764 #-}
   rule764 = \ _beta ->
     _beta
   {-# INLINE rule765 #-}
   rule765 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule766 #-}
   rule766 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule767 #-}
   rule767 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule768 #-}
   rule768 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule769 #-}
   rule769 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule770 #-}
   rule770 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule771 #-}
   rule771 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Expression_Feedback #-}
sem_Expression_Feedback :: T_Range  -> (String) -> T_Expression  -> T_Expression 
sem_Expression_Feedback arg_range_ arg_feedback_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule772 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule773 _expressionIunboundNames
         _self = rule774 _expressionIself _rangeIself arg_feedback_
         _lhsOself :: Expression
         _lhsOself = rule775 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule776 _expressionIassumptions
         _lhsObeta :: Tp
         _lhsObeta = rule777 _expressionIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule778 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule779 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule780 _expressionIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule781 _expressionIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule782 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule783 _expressionIdictionaryEnvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule784 _expressionIinfoTree
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule785 _expressionImatchIO
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule786 _expressionImatches
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule787 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule788 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule789 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule790 _lhsIallPatterns
         _expressionOallTypeSchemes = rule791 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule792 _lhsIavailablePredicates
         _expressionObetaUnique = rule793 _lhsIbetaUnique
         _expressionOclassEnvironment = rule794 _lhsIclassEnvironment
         _expressionOcollectErrors = rule795 _lhsIcollectErrors
         _expressionOcollectWarnings = rule796 _lhsIcollectWarnings
         _expressionOcounter = rule797 _lhsIcounter
         _expressionOcurrentChunk = rule798 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule799 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule800 _lhsIimportEnvironment
         _expressionOmatchIO = rule801 _lhsImatchIO
         _expressionOmonos = rule802 _lhsImonos
         _expressionOnamesInScope = rule803 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule804 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule805 _lhsIparentTree
         _expressionOpatternMatchWarnings = rule806 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule807 _lhsIsubstitution
         _expressionOtryPatterns = rule808 _lhsItryPatterns
         _expressionOtypeschemeMap = rule809 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule810 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule811 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule772 #-}
   rule772 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule773 #-}
   rule773 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule774 #-}
   rule774 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) feedback_ ->
     Expression_Feedback _rangeIself feedback_ _expressionIself
   {-# INLINE rule775 #-}
   rule775 = \ _self ->
     _self
   {-# INLINE rule776 #-}
   rule776 = \ ((_expressionIassumptions) :: Assumptions) ->
     _expressionIassumptions
   {-# INLINE rule777 #-}
   rule777 = \ ((_expressionIbeta) :: Tp) ->
     _expressionIbeta
   {-# INLINE rule778 #-}
   rule778 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule779 #-}
   rule779 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule780 #-}
   rule780 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule781 #-}
   rule781 = \ ((_expressionIconstraints) :: ConstraintSet) ->
     _expressionIconstraints
   {-# INLINE rule782 #-}
   rule782 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule783 #-}
   rule783 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule784 #-}
   rule784 = \ ((_expressionIinfoTree) :: InfoTree) ->
     _expressionIinfoTree
   {-# INLINE rule785 #-}
   rule785 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule786 #-}
   rule786 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
     _expressionImatches
   {-# INLINE rule787 #-}
   rule787 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule788 #-}
   rule788 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule789 #-}
   rule789 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule790 #-}
   rule790 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule791 #-}
   rule791 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule792 #-}
   rule792 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule793 #-}
   rule793 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule794 #-}
   rule794 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule795 #-}
   rule795 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule796 #-}
   rule796 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule797 #-}
   rule797 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule798 #-}
   rule798 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule799 #-}
   rule799 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule800 #-}
   rule800 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule801 #-}
   rule801 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule802 #-}
   rule802 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule803 #-}
   rule803 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule804 #-}
   rule804 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule805 #-}
   rule805 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule806 #-}
   rule806 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule807 #-}
   rule807 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule808 #-}
   rule808 = \ ((_lhsItryPatterns) :: [(Expression     , [String])]) ->
     _lhsItryPatterns
   {-# INLINE rule809 #-}
   rule809 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule810 #-}
   rule810 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule811 #-}
   rule811 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_MustUse #-}
sem_Expression_MustUse :: T_Range  -> T_Expression  -> T_Expression 
sem_Expression_MustUse arg_range_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule812 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule813 _expressionIunboundNames
         _self = rule814 _expressionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule815 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule816 _expressionIassumptions
         _lhsObeta :: Tp
         _lhsObeta = rule817 _expressionIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule818 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule819 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule820 _expressionIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule821 _expressionIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule822 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule823 _expressionIdictionaryEnvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule824 _expressionIinfoTree
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule825 _expressionImatchIO
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule826 _expressionImatches
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule827 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule828 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule829 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule830 _lhsIallPatterns
         _expressionOallTypeSchemes = rule831 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule832 _lhsIavailablePredicates
         _expressionObetaUnique = rule833 _lhsIbetaUnique
         _expressionOclassEnvironment = rule834 _lhsIclassEnvironment
         _expressionOcollectErrors = rule835 _lhsIcollectErrors
         _expressionOcollectWarnings = rule836 _lhsIcollectWarnings
         _expressionOcounter = rule837 _lhsIcounter
         _expressionOcurrentChunk = rule838 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule839 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule840 _lhsIimportEnvironment
         _expressionOmatchIO = rule841 _lhsImatchIO
         _expressionOmonos = rule842 _lhsImonos
         _expressionOnamesInScope = rule843 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule844 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule845 _lhsIparentTree
         _expressionOpatternMatchWarnings = rule846 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule847 _lhsIsubstitution
         _expressionOtryPatterns = rule848 _lhsItryPatterns
         _expressionOtypeschemeMap = rule849 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule850 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule851 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule812 #-}
   rule812 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule813 #-}
   rule813 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule814 #-}
   rule814 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_MustUse _rangeIself _expressionIself
   {-# INLINE rule815 #-}
   rule815 = \ _self ->
     _self
   {-# INLINE rule816 #-}
   rule816 = \ ((_expressionIassumptions) :: Assumptions) ->
     _expressionIassumptions
   {-# INLINE rule817 #-}
   rule817 = \ ((_expressionIbeta) :: Tp) ->
     _expressionIbeta
   {-# INLINE rule818 #-}
   rule818 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule819 #-}
   rule819 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule820 #-}
   rule820 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule821 #-}
   rule821 = \ ((_expressionIconstraints) :: ConstraintSet) ->
     _expressionIconstraints
   {-# INLINE rule822 #-}
   rule822 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule823 #-}
   rule823 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule824 #-}
   rule824 = \ ((_expressionIinfoTree) :: InfoTree) ->
     _expressionIinfoTree
   {-# INLINE rule825 #-}
   rule825 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule826 #-}
   rule826 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
     _expressionImatches
   {-# INLINE rule827 #-}
   rule827 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule828 #-}
   rule828 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule829 #-}
   rule829 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule830 #-}
   rule830 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule831 #-}
   rule831 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule832 #-}
   rule832 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule833 #-}
   rule833 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule834 #-}
   rule834 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule835 #-}
   rule835 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule836 #-}
   rule836 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule837 #-}
   rule837 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule838 #-}
   rule838 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule839 #-}
   rule839 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule840 #-}
   rule840 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule841 #-}
   rule841 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule842 #-}
   rule842 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule843 #-}
   rule843 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule844 #-}
   rule844 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule845 #-}
   rule845 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule846 #-}
   rule846 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule847 #-}
   rule847 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule848 #-}
   rule848 = \ ((_lhsItryPatterns) :: [(Expression     , [String])]) ->
     _lhsItryPatterns
   {-# INLINE rule849 #-}
   rule849 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule850 #-}
   rule850 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule851 #-}
   rule851 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Literal #-}
sem_Expression_Literal :: T_Range  -> T_Literal  -> T_Expression 
sem_Expression_Literal arg_range_ arg_literal_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule852 _lhsIbetaUnique
         _assumptions = rule853  ()
         _constraints = rule854 _beta _cinfo _literalIliteralType
         _beta = rule855 _lhsIbetaUnique
         _cinfo = rule856 _parentTree
         _localInfo = rule857 _beta _lhsImonos _self
         _parentTree = rule858 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule859 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule860 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _literalIself _localInfo
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule861 _ioMatch _lhsImatchIO
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule862  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule863  ()
         _self = rule864 _literalIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule865 _self
         _lhsObeta :: Tp
         _lhsObeta = rule866 _beta
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule867 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule868 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule869 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule870 _lhsIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule871 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule872 _lhsIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule852 #-}
   rule852 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule853 #-}
   rule853 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule854 #-}
   rule854 = \ _beta _cinfo ((_literalIliteralType) :: Tp) ->
                            unitTree ((_literalIliteralType .==. _beta) _cinfo)
   {-# INLINE rule855 #-}
   rule855 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule856 #-}
   rule856 = \ _parentTree ->
     resultConstraint "literal" _parentTree
        [ FolkloreConstraint, HasTrustFactor 10.0 ]
   {-# INLINE rule857 #-}
   rule857 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule858 #-}
   rule858 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule859 #-}
   rule859 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule860 #-}
   rule860 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) ((_lhsIuniqueSecondRound) :: Int) ((_literalIself) :: Literal) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in match0 infoTuple _lhsIuniqueSecondRound
                      (match_Expression_Literal _literalIself)
                      _lhsItryPatterns _lhsIallPatterns
                      []
   {-# INLINE rule861 #-}
   rule861 = \ _ioMatch ((_lhsImatchIO) :: IO ()) ->
                                       _lhsImatchIO             >> _ioMatch
   {-# INLINE rule862 #-}
   rule862 = \  (_ :: ()) ->
     []
   {-# INLINE rule863 #-}
   rule863 = \  (_ :: ()) ->
     []
   {-# INLINE rule864 #-}
   rule864 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
     Expression_Literal _rangeIself _literalIself
   {-# INLINE rule865 #-}
   rule865 = \ _self ->
     _self
   {-# INLINE rule866 #-}
   rule866 = \ _beta ->
     _beta
   {-# INLINE rule867 #-}
   rule867 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule868 #-}
   rule868 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule869 #-}
   rule869 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule870 #-}
   rule870 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule871 #-}
   rule871 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule872 #-}
   rule872 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Expression_Variable #-}
sem_Expression_Variable :: T_Range  -> T_Name  -> T_Expression 
sem_Expression_Variable arg_range_ arg_name_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule873 _lhsIbetaUnique
         _assumptions = rule874 _beta _nameIself
         _constraints = rule875 _lhsIbetaUnique
         _beta = rule876 _lhsIbetaUnique
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule877 _newDEnv
         _nameInScope = rule878 _lhsInamesInScope _nameIself
         _maybeInferredType = rule879 _lhsIallTypeSchemes _nameInScope
         _requiredDictionaries = rule880 _lhsIimportEnvironment _lhsIsubstitution _maybeInferredType _usedAsType
         _newDEnv = rule881 _lhsIavailablePredicates _lhsIclassEnvironment _lhsIdictionaryEnvironment _lhsIsubstitution _nameIself _requiredDictionaries
         _usedAsType = rule882 _beta _lhsIsubstitution
         _localInfo = rule883 _beta _lhsImonos _self
         _parentTree = rule884 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule885 _parentTree
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule886 _nameIself
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule887 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _localInfo _nameIself
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule888 _ioMatch _lhsImatchIO
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule889  ()
         _self = rule890 _nameIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule891 _self
         _lhsObeta :: Tp
         _lhsObeta = rule892 _beta
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule893 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule894 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule895 _lhsIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule896 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule897 _lhsIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule873 #-}
   rule873 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule874 #-}
   rule874 = \ _beta ((_nameIself) :: Name) ->
                            _nameIself `single` _beta
   {-# INLINE rule875 #-}
   rule875 = \ ((_lhsIbetaUnique) :: Int) ->
                            Node [ Receive _lhsIbetaUnique ]
   {-# INLINE rule876 #-}
   rule876 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule877 #-}
   rule877 = \ _newDEnv ->
                                               _newDEnv
   {-# INLINE rule878 #-}
   rule878 = \ ((_lhsInamesInScope) :: Names) ((_nameIself) :: Name) ->
                                               case filter (_nameIself==) _lhsInamesInScope of
                                                  [name] -> NameWithRange name
                                                  _      -> internalError "TypeInferenceOverloading.ag" "n/a" "name not in scope"
   {-# INLINE rule879 #-}
   rule879 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _nameInScope ->
                                               M.lookup _nameInScope _lhsIallTypeSchemes
   {-# INLINE rule880 #-}
   rule880 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _maybeInferredType _usedAsType ->
                                               case _maybeInferredType of
                                                  Nothing     -> []
                                                  Just scheme -> getRequiredDictionaries
                                                                    (getOrderedTypeSynonyms _lhsIimportEnvironment)
                                                                    (_lhsIsubstitution |-> _usedAsType)
                                                                    (_lhsIsubstitution |-> scheme)
   {-# INLINE rule881 #-}
   rule881 = \ ((_lhsIavailablePredicates) :: Predicates) ((_lhsIclassEnvironment) :: ClassEnvironment) ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_nameIself) :: Name) _requiredDictionaries ->
                                               resolveOverloading (_lhsIclassEnvironment)
                                                                  _nameIself
                                                                  (_lhsIsubstitution |-> _lhsIavailablePredicates)
                                                                  (_lhsIsubstitution |-> _requiredDictionaries)
                                                                  _lhsIdictionaryEnvironment
   {-# INLINE rule882 #-}
   rule882 = \ _beta ((_lhsIsubstitution) :: FixpointSubstitution) ->
                                               _lhsIsubstitution |-> _beta
   {-# INLINE rule883 #-}
   rule883 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule884 #-}
   rule884 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule885 #-}
   rule885 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule886 #-}
   rule886 = \ ((_nameIself) :: Name) ->
                                      [ _nameIself ]
   {-# INLINE rule887 #-}
   rule887 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) ((_lhsIuniqueSecondRound) :: Int) _localInfo ((_nameIself) :: Name) ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in match0 infoTuple _lhsIuniqueSecondRound
                      (match_Expression_Variable _nameIself)
                      _lhsItryPatterns _lhsIallPatterns
                      []
   {-# INLINE rule888 #-}
   rule888 = \ _ioMatch ((_lhsImatchIO) :: IO ()) ->
                                       _lhsImatchIO             >> _ioMatch
   {-# INLINE rule889 #-}
   rule889 = \  (_ :: ()) ->
     []
   {-# INLINE rule890 #-}
   rule890 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Expression_Variable _rangeIself _nameIself
   {-# INLINE rule891 #-}
   rule891 = \ _self ->
     _self
   {-# INLINE rule892 #-}
   rule892 = \ _beta ->
     _beta
   {-# INLINE rule893 #-}
   rule893 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule894 #-}
   rule894 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule895 #-}
   rule895 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule896 #-}
   rule896 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule897 #-}
   rule897 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Expression_Constructor #-}
sem_Expression_Constructor :: T_Range  -> T_Name  -> T_Expression 
sem_Expression_Constructor arg_range_ arg_name_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule898 _lhsIbetaUnique
         _assumptions = rule899  ()
         _constraints = rule900 _newcon
         _beta = rule901 _lhsIbetaUnique
         _newcon = rule902 _beta _cinfo _lhsIimportEnvironment _nameIself
         _cinfo = rule903 _nameIself _parentTree
         _localInfo = rule904 _beta _lhsImonos _self
         _parentTree = rule905 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule906 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule907 _assumptions _constraints _lhsIallPatterns _lhsItryPatterns _lhsIuniqueSecondRound _localInfo _nameIself
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule908 _ioMatch _lhsImatchIO
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule909  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule910  ()
         _self = rule911 _nameIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule912 _self
         _lhsObeta :: Tp
         _lhsObeta = rule913 _beta
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule914 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule915 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule916 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule917 _lhsIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule918 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule919 _lhsIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule898 #-}
   rule898 = \ ((_lhsIbetaUnique) :: Int) ->
                             _lhsIbetaUnique + 1
   {-# INLINE rule899 #-}
   rule899 = \  (_ :: ()) ->
                             noAssumptions
   {-# INLINE rule900 #-}
   rule900 = \ _newcon ->
                             listTree _newcon
   {-# INLINE rule901 #-}
   rule901 = \ ((_lhsIbetaUnique) :: Int) ->
                             TVar _lhsIbetaUnique
   {-# INLINE rule902 #-}
   rule902 = \ _beta _cinfo ((_lhsIimportEnvironment) :: ImportEnvironment) ((_nameIself) :: Name) ->
                             case M.lookup _nameIself (valueConstructors _lhsIimportEnvironment) of
                                Nothing  -> []
                                Just ctp -> [ (_beta .::. ctp) _cinfo ]
   {-# INLINE rule903 #-}
   rule903 = \ ((_nameIself) :: Name) _parentTree ->
     resultConstraint "constructor" _parentTree
        [ FolkloreConstraint, HasTrustFactor 10.0, IsImported _nameIself ]
   {-# INLINE rule904 #-}
   rule904 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule905 #-}
   rule905 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule906 #-}
   rule906 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule907 #-}
   rule907 = \ _assumptions _constraints ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) ((_lhsIuniqueSecondRound) :: Int) _localInfo ((_nameIself) :: Name) ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in match0 infoTuple _lhsIuniqueSecondRound
                      (match_Expression_Constructor _nameIself)
                      _lhsItryPatterns _lhsIallPatterns
                      []
   {-# INLINE rule908 #-}
   rule908 = \ _ioMatch ((_lhsImatchIO) :: IO ()) ->
                                       _lhsImatchIO             >> _ioMatch
   {-# INLINE rule909 #-}
   rule909 = \  (_ :: ()) ->
     []
   {-# INLINE rule910 #-}
   rule910 = \  (_ :: ()) ->
     []
   {-# INLINE rule911 #-}
   rule911 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Expression_Constructor _rangeIself _nameIself
   {-# INLINE rule912 #-}
   rule912 = \ _self ->
     _self
   {-# INLINE rule913 #-}
   rule913 = \ _beta ->
     _beta
   {-# INLINE rule914 #-}
   rule914 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule915 #-}
   rule915 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule916 #-}
   rule916 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule917 #-}
   rule917 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule918 #-}
   rule918 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule919 #-}
   rule919 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Expression_Parenthesized #-}
sem_Expression_Parenthesized :: T_Range  -> T_Expression  -> T_Expression 
sem_Expression_Parenthesized arg_range_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule920 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule921 _expressionIunboundNames
         _self = rule922 _expressionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule923 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule924 _expressionIassumptions
         _lhsObeta :: Tp
         _lhsObeta = rule925 _expressionIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule926 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule927 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule928 _expressionIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule929 _expressionIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule930 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule931 _expressionIdictionaryEnvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule932 _expressionIinfoTree
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule933 _expressionImatchIO
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule934 _expressionImatches
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule935 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule936 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule937 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule938 _lhsIallPatterns
         _expressionOallTypeSchemes = rule939 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule940 _lhsIavailablePredicates
         _expressionObetaUnique = rule941 _lhsIbetaUnique
         _expressionOclassEnvironment = rule942 _lhsIclassEnvironment
         _expressionOcollectErrors = rule943 _lhsIcollectErrors
         _expressionOcollectWarnings = rule944 _lhsIcollectWarnings
         _expressionOcounter = rule945 _lhsIcounter
         _expressionOcurrentChunk = rule946 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule947 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule948 _lhsIimportEnvironment
         _expressionOmatchIO = rule949 _lhsImatchIO
         _expressionOmonos = rule950 _lhsImonos
         _expressionOnamesInScope = rule951 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule952 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule953 _lhsIparentTree
         _expressionOpatternMatchWarnings = rule954 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule955 _lhsIsubstitution
         _expressionOtryPatterns = rule956 _lhsItryPatterns
         _expressionOtypeschemeMap = rule957 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule958 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule959 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule920 #-}
   rule920 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule921 #-}
   rule921 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule922 #-}
   rule922 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_Parenthesized _rangeIself _expressionIself
   {-# INLINE rule923 #-}
   rule923 = \ _self ->
     _self
   {-# INLINE rule924 #-}
   rule924 = \ ((_expressionIassumptions) :: Assumptions) ->
     _expressionIassumptions
   {-# INLINE rule925 #-}
   rule925 = \ ((_expressionIbeta) :: Tp) ->
     _expressionIbeta
   {-# INLINE rule926 #-}
   rule926 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule927 #-}
   rule927 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule928 #-}
   rule928 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule929 #-}
   rule929 = \ ((_expressionIconstraints) :: ConstraintSet) ->
     _expressionIconstraints
   {-# INLINE rule930 #-}
   rule930 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule931 #-}
   rule931 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule932 #-}
   rule932 = \ ((_expressionIinfoTree) :: InfoTree) ->
     _expressionIinfoTree
   {-# INLINE rule933 #-}
   rule933 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule934 #-}
   rule934 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
     _expressionImatches
   {-# INLINE rule935 #-}
   rule935 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule936 #-}
   rule936 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule937 #-}
   rule937 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule938 #-}
   rule938 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule939 #-}
   rule939 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule940 #-}
   rule940 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule941 #-}
   rule941 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule942 #-}
   rule942 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule943 #-}
   rule943 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule944 #-}
   rule944 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule945 #-}
   rule945 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule946 #-}
   rule946 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule947 #-}
   rule947 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule948 #-}
   rule948 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule949 #-}
   rule949 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule950 #-}
   rule950 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule951 #-}
   rule951 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule952 #-}
   rule952 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule953 #-}
   rule953 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule954 #-}
   rule954 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule955 #-}
   rule955 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule956 #-}
   rule956 = \ ((_lhsItryPatterns) :: [(Expression     , [String])]) ->
     _lhsItryPatterns
   {-# INLINE rule957 #-}
   rule957 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule958 #-}
   rule958 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule959 #-}
   rule959 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_NormalApplication #-}
sem_Expression_NormalApplication :: T_Range  -> T_Expression  -> T_Expressions  -> T_Expression 
sem_Expression_NormalApplication arg_range_ arg_function_ arg_arguments_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _functionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_function_))
         _argumentsX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_arguments_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _functionIassumptions _functionIbeta _functionIbetaUnique _functionIcollectErrors _functionIcollectInstances _functionIcollectWarnings _functionIconstraints _functionIcounter _functionIdictionaryEnvironment _functionIinfoTree _functionImatchIO _functionImatches _functionIpatternMatchWarnings _functionIself _functionIunboundNames _functionIuniqueChunk _functionIuniqueSecondRound) = inv_Expression_s41 _functionX41 (T_Expression_vIn40 _functionOallPatterns _functionOallTypeSchemes _functionOavailablePredicates _functionObetaUnique _functionOclassEnvironment _functionOcollectErrors _functionOcollectWarnings _functionOcounter _functionOcurrentChunk _functionOdictionaryEnvironment _functionOimportEnvironment _functionOmatchIO _functionOmonos _functionOnamesInScope _functionOorderedTypeSynonyms _functionOparentTree _functionOpatternMatchWarnings _functionOsubstitution _functionOtryPatterns _functionOtypeschemeMap _functionOuniqueChunk _functionOuniqueSecondRound)
         (T_Expressions_vOut43 _argumentsIassumptions _argumentsIbetaUnique _argumentsIbetas _argumentsIcollectErrors _argumentsIcollectInstances _argumentsIcollectWarnings _argumentsIconstraintslist _argumentsIcounter _argumentsIdictionaryEnvironment _argumentsIinfoTrees _argumentsImatchIO _argumentsImatches _argumentsIpatternMatchWarnings _argumentsIself _argumentsIunboundNames _argumentsIuniqueChunk _argumentsIuniqueSecondRound) = inv_Expressions_s44 _argumentsX44 (T_Expressions_vIn43 _argumentsOallPatterns _argumentsOallTypeSchemes _argumentsOavailablePredicates _argumentsObetaUnique _argumentsOclassEnvironment _argumentsOcollectErrors _argumentsOcollectWarnings _argumentsOcounter _argumentsOcurrentChunk _argumentsOdictionaryEnvironment _argumentsOimportEnvironment _argumentsOmatchIO _argumentsOmonos _argumentsOnamesInScope _argumentsOorderedTypeSynonyms _argumentsOparentTree _argumentsOpatternMatchWarnings _argumentsOsubstitution _argumentsOtryPatterns _argumentsOtypeschemeMap _argumentsOuniqueChunk _argumentsOuniqueSecondRound)
         _functionObetaUnique = rule960 _lhsIbetaUnique
         _assumptions = rule961 _argumentsIassumptions _functionIassumptions
         _constraints = rule962 _argumentsIconstraintslist _functionIconstraints _newcon
         _beta = rule963 _lhsIbetaUnique
         _newcon = rule964 _argumentsIbetas _beta _cinfo _functionIbeta
         _cinfo = rule965 _argumentsIinfoTrees _parentTree
         _localInfo = rule966 _beta _lhsImonos _self
         _parentTree = rule967 _argumentsIinfoTrees _functionIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule968 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((_functionOtryPatterns,_argumentsOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule969 _argumentsImatches _argumentsIuniqueSecondRound _assumptions _constraints _functionImatches _lhsIallPatterns _lhsItryPatterns _localInfo
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule970 _argumentsImatchIO _ioMatch
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule971 _argumentsIcollectInstances _functionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule972 _argumentsIunboundNames _functionIunboundNames
         _self = rule973 _argumentsIself _functionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule974 _self
         _lhsObeta :: Tp
         _lhsObeta = rule975 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule976 _argumentsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule977 _argumentsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule978 _argumentsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule979 _argumentsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule980 _argumentsIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule981 _argumentsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule982 _argumentsIuniqueChunk
         _functionOallPatterns = rule983 _lhsIallPatterns
         _functionOallTypeSchemes = rule984 _lhsIallTypeSchemes
         _functionOavailablePredicates = rule985 _lhsIavailablePredicates
         _functionOclassEnvironment = rule986 _lhsIclassEnvironment
         _functionOcollectErrors = rule987 _lhsIcollectErrors
         _functionOcollectWarnings = rule988 _lhsIcollectWarnings
         _functionOcounter = rule989 _lhsIcounter
         _functionOcurrentChunk = rule990 _lhsIcurrentChunk
         _functionOdictionaryEnvironment = rule991 _lhsIdictionaryEnvironment
         _functionOimportEnvironment = rule992 _lhsIimportEnvironment
         _functionOmatchIO = rule993 _lhsImatchIO
         _functionOmonos = rule994 _lhsImonos
         _functionOnamesInScope = rule995 _lhsInamesInScope
         _functionOorderedTypeSynonyms = rule996 _lhsIorderedTypeSynonyms
         _functionOparentTree = rule997 _parentTree
         _functionOpatternMatchWarnings = rule998 _lhsIpatternMatchWarnings
         _functionOsubstitution = rule999 _lhsIsubstitution
         _functionOtypeschemeMap = rule1000 _lhsItypeschemeMap
         _functionOuniqueChunk = rule1001 _lhsIuniqueChunk
         _functionOuniqueSecondRound = rule1002 _lhsIuniqueSecondRound
         _argumentsOallPatterns = rule1003 _lhsIallPatterns
         _argumentsOallTypeSchemes = rule1004 _lhsIallTypeSchemes
         _argumentsOavailablePredicates = rule1005 _lhsIavailablePredicates
         _argumentsObetaUnique = rule1006 _functionIbetaUnique
         _argumentsOclassEnvironment = rule1007 _lhsIclassEnvironment
         _argumentsOcollectErrors = rule1008 _functionIcollectErrors
         _argumentsOcollectWarnings = rule1009 _functionIcollectWarnings
         _argumentsOcounter = rule1010 _functionIcounter
         _argumentsOcurrentChunk = rule1011 _lhsIcurrentChunk
         _argumentsOdictionaryEnvironment = rule1012 _functionIdictionaryEnvironment
         _argumentsOimportEnvironment = rule1013 _lhsIimportEnvironment
         _argumentsOmatchIO = rule1014 _functionImatchIO
         _argumentsOmonos = rule1015 _lhsImonos
         _argumentsOnamesInScope = rule1016 _lhsInamesInScope
         _argumentsOorderedTypeSynonyms = rule1017 _lhsIorderedTypeSynonyms
         _argumentsOparentTree = rule1018 _parentTree
         _argumentsOpatternMatchWarnings = rule1019 _functionIpatternMatchWarnings
         _argumentsOsubstitution = rule1020 _lhsIsubstitution
         _argumentsOtypeschemeMap = rule1021 _lhsItypeschemeMap
         _argumentsOuniqueChunk = rule1022 _functionIuniqueChunk
         _argumentsOuniqueSecondRound = rule1023 _functionIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule960 #-}
   rule960 = \ ((_lhsIbetaUnique) :: Int) ->
                                 _lhsIbetaUnique + 1
   {-# INLINE rule961 #-}
   rule961 = \ ((_argumentsIassumptions) :: Assumptions) ((_functionIassumptions) :: Assumptions) ->
                                 _functionIassumptions `combine` _argumentsIassumptions
   {-# INLINE rule962 #-}
   rule962 = \ ((_argumentsIconstraintslist) :: ConstraintSets) ((_functionIconstraints) :: ConstraintSet) _newcon ->
                                 _newcon .>.
                                 Node [ _functionIconstraints
                                      , Node _argumentsIconstraintslist
                                      ]
   {-# INLINE rule963 #-}
   rule963 = \ ((_lhsIbetaUnique) :: Int) ->
                                 TVar _lhsIbetaUnique
   {-# INLINE rule964 #-}
   rule964 = \ ((_argumentsIbetas) :: Tps) _beta _cinfo ((_functionIbeta) :: Tp) ->
                                 [ (_functionIbeta .==. foldr (.->.) _beta _argumentsIbetas) _cinfo ]
   {-# INLINE rule965 #-}
   rule965 = \ ((_argumentsIinfoTrees) :: InfoTrees) _parentTree ->
     childConstraint 0 "application" _parentTree
        [ ApplicationEdge False (map attribute _argumentsIinfoTrees) ]
   {-# INLINE rule966 #-}
   rule966 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule967 #-}
   rule967 = \ ((_argumentsIinfoTrees) :: InfoTrees) ((_functionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo (_functionIinfoTree : _argumentsIinfoTrees)
   {-# INLINE rule968 #-}
   rule968 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule969 #-}
   rule969 = \ ((_argumentsImatches) :: [Maybe MetaVariableTable]) ((_argumentsIuniqueSecondRound) :: Int) _assumptions _constraints ((_functionImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
             let infoTuple = metaVarInfo _constraints _assumptions _localInfo
             in match2 infoTuple _argumentsIuniqueSecondRound
                       match_Expression_NormalApplication
                       _lhsItryPatterns _lhsIallPatterns
                       [_functionImatches, _argumentsImatches]
   {-# INLINE rule970 #-}
   rule970 = \ ((_argumentsImatchIO) :: IO ()) _ioMatch ->
                                       _argumentsImatchIO       >> _ioMatch
   {-# INLINE rule971 #-}
   rule971 = \ ((_argumentsIcollectInstances) :: [(Name, Instance)]) ((_functionIcollectInstances) :: [(Name, Instance)]) ->
     _functionIcollectInstances  ++  _argumentsIcollectInstances
   {-# INLINE rule972 #-}
   rule972 = \ ((_argumentsIunboundNames) :: Names) ((_functionIunboundNames) :: Names) ->
     _functionIunboundNames ++ _argumentsIunboundNames
   {-# INLINE rule973 #-}
   rule973 = \ ((_argumentsIself) :: Expressions) ((_functionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_NormalApplication _rangeIself _functionIself _argumentsIself
   {-# INLINE rule974 #-}
   rule974 = \ _self ->
     _self
   {-# INLINE rule975 #-}
   rule975 = \ _beta ->
     _beta
   {-# INLINE rule976 #-}
   rule976 = \ ((_argumentsIbetaUnique) :: Int) ->
     _argumentsIbetaUnique
   {-# INLINE rule977 #-}
   rule977 = \ ((_argumentsIcollectErrors) :: TypeErrors) ->
     _argumentsIcollectErrors
   {-# INLINE rule978 #-}
   rule978 = \ ((_argumentsIcollectWarnings) :: Warnings) ->
     _argumentsIcollectWarnings
   {-# INLINE rule979 #-}
   rule979 = \ ((_argumentsIcounter) :: Int) ->
     _argumentsIcounter
   {-# INLINE rule980 #-}
   rule980 = \ ((_argumentsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _argumentsIdictionaryEnvironment
   {-# INLINE rule981 #-}
   rule981 = \ ((_argumentsIpatternMatchWarnings) :: [Warning]) ->
     _argumentsIpatternMatchWarnings
   {-# INLINE rule982 #-}
   rule982 = \ ((_argumentsIuniqueChunk) :: Int) ->
     _argumentsIuniqueChunk
   {-# INLINE rule983 #-}
   rule983 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule984 #-}
   rule984 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule985 #-}
   rule985 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule986 #-}
   rule986 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule987 #-}
   rule987 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule988 #-}
   rule988 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule989 #-}
   rule989 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule990 #-}
   rule990 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule991 #-}
   rule991 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule992 #-}
   rule992 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule993 #-}
   rule993 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule994 #-}
   rule994 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule995 #-}
   rule995 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule996 #-}
   rule996 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule997 #-}
   rule997 = \ _parentTree ->
     _parentTree
   {-# INLINE rule998 #-}
   rule998 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule999 #-}
   rule999 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1000 #-}
   rule1000 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1001 #-}
   rule1001 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1002 #-}
   rule1002 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1003 #-}
   rule1003 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1004 #-}
   rule1004 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1005 #-}
   rule1005 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1006 #-}
   rule1006 = \ ((_functionIbetaUnique) :: Int) ->
     _functionIbetaUnique
   {-# INLINE rule1007 #-}
   rule1007 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1008 #-}
   rule1008 = \ ((_functionIcollectErrors) :: TypeErrors) ->
     _functionIcollectErrors
   {-# INLINE rule1009 #-}
   rule1009 = \ ((_functionIcollectWarnings) :: Warnings) ->
     _functionIcollectWarnings
   {-# INLINE rule1010 #-}
   rule1010 = \ ((_functionIcounter) :: Int) ->
     _functionIcounter
   {-# INLINE rule1011 #-}
   rule1011 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1012 #-}
   rule1012 = \ ((_functionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _functionIdictionaryEnvironment
   {-# INLINE rule1013 #-}
   rule1013 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1014 #-}
   rule1014 = \ ((_functionImatchIO) :: IO ()) ->
     _functionImatchIO
   {-# INLINE rule1015 #-}
   rule1015 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1016 #-}
   rule1016 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1017 #-}
   rule1017 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1018 #-}
   rule1018 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1019 #-}
   rule1019 = \ ((_functionIpatternMatchWarnings) :: [Warning]) ->
     _functionIpatternMatchWarnings
   {-# INLINE rule1020 #-}
   rule1020 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1021 #-}
   rule1021 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1022 #-}
   rule1022 = \ ((_functionIuniqueChunk) :: Int) ->
     _functionIuniqueChunk
   {-# INLINE rule1023 #-}
   rule1023 = \ ((_functionIuniqueSecondRound) :: Int) ->
     _functionIuniqueSecondRound
{-# NOINLINE sem_Expression_InfixApplication #-}
sem_Expression_InfixApplication :: T_Range  -> T_MaybeExpression  -> T_Expression  -> T_MaybeExpression  -> T_Expression 
sem_Expression_InfixApplication arg_range_ arg_leftExpression_ arg_operator_ arg_rightExpression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _leftExpressionX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_leftExpression_))
         _operatorX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_operator_))
         _rightExpressionX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_rightExpression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_MaybeExpression_vOut94 _leftExpressionIassumptions _leftExpressionIbeta _leftExpressionIbetaUnique _leftExpressionIcollectErrors _leftExpressionIcollectInstances _leftExpressionIcollectWarnings _leftExpressionIconstraints _leftExpressionIcounter _leftExpressionIdictionaryEnvironment _leftExpressionIinfoTrees _leftExpressionImatchIO _leftExpressionImatches _leftExpressionIpatternMatchWarnings _leftExpressionIsection _leftExpressionIself _leftExpressionIunboundNames _leftExpressionIuniqueChunk _leftExpressionIuniqueSecondRound) = inv_MaybeExpression_s95 _leftExpressionX95 (T_MaybeExpression_vIn94 _leftExpressionOallPatterns _leftExpressionOallTypeSchemes _leftExpressionOavailablePredicates _leftExpressionObetaUnique _leftExpressionOclassEnvironment _leftExpressionOcollectErrors _leftExpressionOcollectWarnings _leftExpressionOcounter _leftExpressionOcurrentChunk _leftExpressionOdictionaryEnvironment _leftExpressionOimportEnvironment _leftExpressionOmatchIO _leftExpressionOmonos _leftExpressionOnamesInScope _leftExpressionOorderedTypeSynonyms _leftExpressionOparentTree _leftExpressionOpatternMatchWarnings _leftExpressionOsubstitution _leftExpressionOtryPatterns _leftExpressionOtypeschemeMap _leftExpressionOuniqueChunk _leftExpressionOuniqueSecondRound)
         (T_Expression_vOut40 _operatorIassumptions _operatorIbeta _operatorIbetaUnique _operatorIcollectErrors _operatorIcollectInstances _operatorIcollectWarnings _operatorIconstraints _operatorIcounter _operatorIdictionaryEnvironment _operatorIinfoTree _operatorImatchIO _operatorImatches _operatorIpatternMatchWarnings _operatorIself _operatorIunboundNames _operatorIuniqueChunk _operatorIuniqueSecondRound) = inv_Expression_s41 _operatorX41 (T_Expression_vIn40 _operatorOallPatterns _operatorOallTypeSchemes _operatorOavailablePredicates _operatorObetaUnique _operatorOclassEnvironment _operatorOcollectErrors _operatorOcollectWarnings _operatorOcounter _operatorOcurrentChunk _operatorOdictionaryEnvironment _operatorOimportEnvironment _operatorOmatchIO _operatorOmonos _operatorOnamesInScope _operatorOorderedTypeSynonyms _operatorOparentTree _operatorOpatternMatchWarnings _operatorOsubstitution _operatorOtryPatterns _operatorOtypeschemeMap _operatorOuniqueChunk _operatorOuniqueSecondRound)
         (T_MaybeExpression_vOut94 _rightExpressionIassumptions _rightExpressionIbeta _rightExpressionIbetaUnique _rightExpressionIcollectErrors _rightExpressionIcollectInstances _rightExpressionIcollectWarnings _rightExpressionIconstraints _rightExpressionIcounter _rightExpressionIdictionaryEnvironment _rightExpressionIinfoTrees _rightExpressionImatchIO _rightExpressionImatches _rightExpressionIpatternMatchWarnings _rightExpressionIsection _rightExpressionIself _rightExpressionIunboundNames _rightExpressionIuniqueChunk _rightExpressionIuniqueSecondRound) = inv_MaybeExpression_s95 _rightExpressionX95 (T_MaybeExpression_vIn94 _rightExpressionOallPatterns _rightExpressionOallTypeSchemes _rightExpressionOavailablePredicates _rightExpressionObetaUnique _rightExpressionOclassEnvironment _rightExpressionOcollectErrors _rightExpressionOcollectWarnings _rightExpressionOcounter _rightExpressionOcurrentChunk _rightExpressionOdictionaryEnvironment _rightExpressionOimportEnvironment _rightExpressionOmatchIO _rightExpressionOmonos _rightExpressionOnamesInScope _rightExpressionOorderedTypeSynonyms _rightExpressionOparentTree _rightExpressionOpatternMatchWarnings _rightExpressionOsubstitution _rightExpressionOtryPatterns _rightExpressionOtypeschemeMap _rightExpressionOuniqueChunk _rightExpressionOuniqueSecondRound)
         _leftExpressionObetaUnique = rule1024 _lhsIbetaUnique
         _assumptions = rule1025 _leftExpressionIassumptions _operatorIassumptions _rightExpressionIassumptions
         _constraints = rule1026 _conTotal _leftExpressionIconstraints _operatorIconstraints _rightExpressionIconstraints
         _beta = rule1027 _lhsIbetaUnique
         _betaResOp = rule1028 _lhsIbetaUnique
         _conOperator = rule1029 _betaResOp _cinfoOperator _leftExpressionIbeta _operatorIbeta _rightExpressionIbeta
         _conTotal = rule1030 _beta _betaResOp _cinfoComplete _cinfoEmpty _cinfoLeftSection _cinfoRightSection _conOperator _leftExpressionIbeta _leftExpressionIsection _operatorIbeta _rightExpressionIbeta _rightExpressionIsection
         _operatorNr = rule1031 _leftExpressionIinfoTrees
         _cinfoOperator = rule1032 _leftExpressionIinfoTrees _leftExpressionIsection _operatorNr _parentTree _rightExpressionIinfoTrees _rightExpressionIsection
         _cinfoComplete = rule1033 _localInfo _parentTree
         _cinfoLeftSection = rule1034 _localInfo _parentTree
         _cinfoRightSection = rule1035 _localInfo _parentTree
         _cinfoEmpty = rule1036 _localInfo _parentTree
         _localInfo = rule1037 _beta _lhsImonos _self
         _parentTree = rule1038 _leftExpressionIinfoTrees _lhsIparentTree _localInfo _operatorIinfoTree _rightExpressionIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1039 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((_leftExpressionOtryPatterns,_operatorOtryPatterns,_rightExpressionOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1040 _assumptions _constraints _leftExpressionImatches _lhsIallPatterns _lhsItryPatterns _localInfo _operatorImatches _rightExpressionImatches _rightExpressionIuniqueSecondRound
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1041 _ioMatch _rightExpressionImatchIO
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1042 _leftExpressionIcollectInstances _operatorIcollectInstances _rightExpressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1043 _leftExpressionIunboundNames _operatorIunboundNames _rightExpressionIunboundNames
         _self = rule1044 _leftExpressionIself _operatorIself _rangeIself _rightExpressionIself
         _lhsOself :: Expression
         _lhsOself = rule1045 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1046 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1047 _rightExpressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1048 _rightExpressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1049 _rightExpressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1050 _rightExpressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1051 _rightExpressionIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1052 _rightExpressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1053 _rightExpressionIuniqueChunk
         _leftExpressionOallPatterns = rule1054 _lhsIallPatterns
         _leftExpressionOallTypeSchemes = rule1055 _lhsIallTypeSchemes
         _leftExpressionOavailablePredicates = rule1056 _lhsIavailablePredicates
         _leftExpressionOclassEnvironment = rule1057 _lhsIclassEnvironment
         _leftExpressionOcollectErrors = rule1058 _lhsIcollectErrors
         _leftExpressionOcollectWarnings = rule1059 _lhsIcollectWarnings
         _leftExpressionOcounter = rule1060 _lhsIcounter
         _leftExpressionOcurrentChunk = rule1061 _lhsIcurrentChunk
         _leftExpressionOdictionaryEnvironment = rule1062 _lhsIdictionaryEnvironment
         _leftExpressionOimportEnvironment = rule1063 _lhsIimportEnvironment
         _leftExpressionOmatchIO = rule1064 _lhsImatchIO
         _leftExpressionOmonos = rule1065 _lhsImonos
         _leftExpressionOnamesInScope = rule1066 _lhsInamesInScope
         _leftExpressionOorderedTypeSynonyms = rule1067 _lhsIorderedTypeSynonyms
         _leftExpressionOparentTree = rule1068 _parentTree
         _leftExpressionOpatternMatchWarnings = rule1069 _lhsIpatternMatchWarnings
         _leftExpressionOsubstitution = rule1070 _lhsIsubstitution
         _leftExpressionOtypeschemeMap = rule1071 _lhsItypeschemeMap
         _leftExpressionOuniqueChunk = rule1072 _lhsIuniqueChunk
         _leftExpressionOuniqueSecondRound = rule1073 _lhsIuniqueSecondRound
         _operatorOallPatterns = rule1074 _lhsIallPatterns
         _operatorOallTypeSchemes = rule1075 _lhsIallTypeSchemes
         _operatorOavailablePredicates = rule1076 _lhsIavailablePredicates
         _operatorObetaUnique = rule1077 _leftExpressionIbetaUnique
         _operatorOclassEnvironment = rule1078 _lhsIclassEnvironment
         _operatorOcollectErrors = rule1079 _leftExpressionIcollectErrors
         _operatorOcollectWarnings = rule1080 _leftExpressionIcollectWarnings
         _operatorOcounter = rule1081 _leftExpressionIcounter
         _operatorOcurrentChunk = rule1082 _lhsIcurrentChunk
         _operatorOdictionaryEnvironment = rule1083 _leftExpressionIdictionaryEnvironment
         _operatorOimportEnvironment = rule1084 _lhsIimportEnvironment
         _operatorOmatchIO = rule1085 _leftExpressionImatchIO
         _operatorOmonos = rule1086 _lhsImonos
         _operatorOnamesInScope = rule1087 _lhsInamesInScope
         _operatorOorderedTypeSynonyms = rule1088 _lhsIorderedTypeSynonyms
         _operatorOparentTree = rule1089 _parentTree
         _operatorOpatternMatchWarnings = rule1090 _leftExpressionIpatternMatchWarnings
         _operatorOsubstitution = rule1091 _lhsIsubstitution
         _operatorOtypeschemeMap = rule1092 _lhsItypeschemeMap
         _operatorOuniqueChunk = rule1093 _leftExpressionIuniqueChunk
         _operatorOuniqueSecondRound = rule1094 _leftExpressionIuniqueSecondRound
         _rightExpressionOallPatterns = rule1095 _lhsIallPatterns
         _rightExpressionOallTypeSchemes = rule1096 _lhsIallTypeSchemes
         _rightExpressionOavailablePredicates = rule1097 _lhsIavailablePredicates
         _rightExpressionObetaUnique = rule1098 _operatorIbetaUnique
         _rightExpressionOclassEnvironment = rule1099 _lhsIclassEnvironment
         _rightExpressionOcollectErrors = rule1100 _operatorIcollectErrors
         _rightExpressionOcollectWarnings = rule1101 _operatorIcollectWarnings
         _rightExpressionOcounter = rule1102 _operatorIcounter
         _rightExpressionOcurrentChunk = rule1103 _lhsIcurrentChunk
         _rightExpressionOdictionaryEnvironment = rule1104 _operatorIdictionaryEnvironment
         _rightExpressionOimportEnvironment = rule1105 _lhsIimportEnvironment
         _rightExpressionOmatchIO = rule1106 _operatorImatchIO
         _rightExpressionOmonos = rule1107 _lhsImonos
         _rightExpressionOnamesInScope = rule1108 _lhsInamesInScope
         _rightExpressionOorderedTypeSynonyms = rule1109 _lhsIorderedTypeSynonyms
         _rightExpressionOparentTree = rule1110 _parentTree
         _rightExpressionOpatternMatchWarnings = rule1111 _operatorIpatternMatchWarnings
         _rightExpressionOsubstitution = rule1112 _lhsIsubstitution
         _rightExpressionOtypeschemeMap = rule1113 _lhsItypeschemeMap
         _rightExpressionOuniqueChunk = rule1114 _operatorIuniqueChunk
         _rightExpressionOuniqueSecondRound = rule1115 _operatorIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1024 #-}
   rule1024 = \ ((_lhsIbetaUnique) :: Int) ->
                                       _lhsIbetaUnique + 2
   {-# INLINE rule1025 #-}
   rule1025 = \ ((_leftExpressionIassumptions) :: Assumptions) ((_operatorIassumptions) :: Assumptions) ((_rightExpressionIassumptions) :: Assumptions) ->
                                       _leftExpressionIassumptions `combine` _operatorIassumptions `combine` _rightExpressionIassumptions
   {-# INLINE rule1026 #-}
   rule1026 = \ _conTotal ((_leftExpressionIconstraints) :: ConstraintSet) ((_operatorIconstraints) :: ConstraintSet) ((_rightExpressionIconstraints) :: ConstraintSet) ->
                                       _conTotal .>.
                                       Node [ _operatorIconstraints
                                            , _leftExpressionIconstraints
                                            , _rightExpressionIconstraints
                                            ]
   {-# INLINE rule1027 #-}
   rule1027 = \ ((_lhsIbetaUnique) :: Int) ->
                                       TVar _lhsIbetaUnique
   {-# INLINE rule1028 #-}
   rule1028 = \ ((_lhsIbetaUnique) :: Int) ->
                                       TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule1029 #-}
   rule1029 = \ _betaResOp _cinfoOperator ((_leftExpressionIbeta) :: Tp) ((_operatorIbeta) :: Tp) ((_rightExpressionIbeta) :: Tp) ->
                                       (_operatorIbeta .==. _leftExpressionIbeta .->. _rightExpressionIbeta .->. _betaResOp) _cinfoOperator
   {-# INLINE rule1030 #-}
   rule1030 = \ _beta _betaResOp _cinfoComplete _cinfoEmpty _cinfoLeftSection _cinfoRightSection _conOperator ((_leftExpressionIbeta) :: Tp) ((_leftExpressionIsection) :: Bool) ((_operatorIbeta) :: Tp) ((_rightExpressionIbeta) :: Tp) ((_rightExpressionIsection) :: Bool) ->
                                       case (_leftExpressionIsection,_rightExpressionIsection) of
                                              (False,False) -> [ _conOperator, (_betaResOp     .==. _beta)                        _cinfoComplete     ]
                                              (True ,True ) -> [               (_operatorIbeta .==. _beta)                        _cinfoEmpty        ]
                                              (False,True ) -> [ _conOperator, (_rightExpressionIbeta .->. _betaResOp .==. _beta) _cinfoRightSection ]
                                              (True ,False) -> [ _conOperator, (_leftExpressionIbeta  .->. _betaResOp .==. _beta) _cinfoLeftSection  ]
   {-# INLINE rule1031 #-}
   rule1031 = \ ((_leftExpressionIinfoTrees) :: InfoTrees) ->
                                                          length _leftExpressionIinfoTrees
   {-# INLINE rule1032 #-}
   rule1032 = \ ((_leftExpressionIinfoTrees) :: InfoTrees) ((_leftExpressionIsection) :: Bool) _operatorNr _parentTree ((_rightExpressionIinfoTrees) :: InfoTrees) ((_rightExpressionIsection) :: Bool) ->
     childConstraint _operatorNr "infix application" _parentTree $
        if _leftExpressionIsection || _rightExpressionIsection
        then [ HasTrustFactor 10.0 ]
        else [ ApplicationEdge True (map attribute (_leftExpressionIinfoTrees ++ _rightExpressionIinfoTrees)) ]
   {-# INLINE rule1033 #-}
   rule1033 = \ _localInfo _parentTree ->
     specialConstraint "infix application (INTERNAL ERROR)" _parentTree
        (self _localInfo, Nothing)
        [ FolkloreConstraint, highlyTrusted ]
   {-# INLINE rule1034 #-}
   rule1034 = \ _localInfo _parentTree ->
     specialConstraint "left section" _parentTree
        (self _localInfo, Nothing)
        [  ]
   {-# INLINE rule1035 #-}
   rule1035 = \ _localInfo _parentTree ->
     specialConstraint "right section" _parentTree
        (self _localInfo, Nothing)
        [ ]
   {-# INLINE rule1036 #-}
   rule1036 = \ _localInfo _parentTree ->
     specialConstraint "infix application" _parentTree
       (self _localInfo, Nothing)
       [ FolkloreConstraint, HasTrustFactor 10.0 ]
   {-# INLINE rule1037 #-}
   rule1037 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1038 #-}
   rule1038 = \ ((_leftExpressionIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ((_operatorIinfoTree) :: InfoTree) ((_rightExpressionIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo
                              (_leftExpressionIinfoTrees ++ [_operatorIinfoTree] ++ _rightExpressionIinfoTrees)
   {-# INLINE rule1039 #-}
   rule1039 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1040 #-}
   rule1040 = \ _assumptions _constraints ((_leftExpressionImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ((_operatorImatches) :: [Maybe MetaVariableTable]) ((_rightExpressionImatches) :: [Maybe MetaVariableTable]) ((_rightExpressionIuniqueSecondRound) :: Int) ->
             let infoTuple = metaVarInfo _constraints _assumptions _localInfo
             in match3 infoTuple _rightExpressionIuniqueSecondRound
                       match_Expression_InfixApplication
                       _lhsItryPatterns _lhsIallPatterns
                       [_leftExpressionImatches, _operatorImatches,_rightExpressionImatches]
   {-# INLINE rule1041 #-}
   rule1041 = \ _ioMatch ((_rightExpressionImatchIO) :: IO ()) ->
                                       _rightExpressionImatchIO >> _ioMatch
   {-# INLINE rule1042 #-}
   rule1042 = \ ((_leftExpressionIcollectInstances) :: [(Name, Instance)]) ((_operatorIcollectInstances) :: [(Name, Instance)]) ((_rightExpressionIcollectInstances) :: [(Name, Instance)]) ->
     _leftExpressionIcollectInstances  ++  _operatorIcollectInstances  ++  _rightExpressionIcollectInstances
   {-# INLINE rule1043 #-}
   rule1043 = \ ((_leftExpressionIunboundNames) :: Names) ((_operatorIunboundNames) :: Names) ((_rightExpressionIunboundNames) :: Names) ->
     _leftExpressionIunboundNames ++ _operatorIunboundNames ++ _rightExpressionIunboundNames
   {-# INLINE rule1044 #-}
   rule1044 = \ ((_leftExpressionIself) :: MaybeExpression) ((_operatorIself) :: Expression) ((_rangeIself) :: Range) ((_rightExpressionIself) :: MaybeExpression) ->
     Expression_InfixApplication _rangeIself _leftExpressionIself _operatorIself _rightExpressionIself
   {-# INLINE rule1045 #-}
   rule1045 = \ _self ->
     _self
   {-# INLINE rule1046 #-}
   rule1046 = \ _beta ->
     _beta
   {-# INLINE rule1047 #-}
   rule1047 = \ ((_rightExpressionIbetaUnique) :: Int) ->
     _rightExpressionIbetaUnique
   {-# INLINE rule1048 #-}
   rule1048 = \ ((_rightExpressionIcollectErrors) :: TypeErrors) ->
     _rightExpressionIcollectErrors
   {-# INLINE rule1049 #-}
   rule1049 = \ ((_rightExpressionIcollectWarnings) :: Warnings) ->
     _rightExpressionIcollectWarnings
   {-# INLINE rule1050 #-}
   rule1050 = \ ((_rightExpressionIcounter) :: Int) ->
     _rightExpressionIcounter
   {-# INLINE rule1051 #-}
   rule1051 = \ ((_rightExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _rightExpressionIdictionaryEnvironment
   {-# INLINE rule1052 #-}
   rule1052 = \ ((_rightExpressionIpatternMatchWarnings) :: [Warning]) ->
     _rightExpressionIpatternMatchWarnings
   {-# INLINE rule1053 #-}
   rule1053 = \ ((_rightExpressionIuniqueChunk) :: Int) ->
     _rightExpressionIuniqueChunk
   {-# INLINE rule1054 #-}
   rule1054 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1055 #-}
   rule1055 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1056 #-}
   rule1056 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1057 #-}
   rule1057 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1058 #-}
   rule1058 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1059 #-}
   rule1059 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1060 #-}
   rule1060 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1061 #-}
   rule1061 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1062 #-}
   rule1062 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1063 #-}
   rule1063 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1064 #-}
   rule1064 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1065 #-}
   rule1065 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1066 #-}
   rule1066 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1067 #-}
   rule1067 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1068 #-}
   rule1068 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1069 #-}
   rule1069 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1070 #-}
   rule1070 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1071 #-}
   rule1071 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1072 #-}
   rule1072 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1073 #-}
   rule1073 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1074 #-}
   rule1074 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1075 #-}
   rule1075 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1076 #-}
   rule1076 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1077 #-}
   rule1077 = \ ((_leftExpressionIbetaUnique) :: Int) ->
     _leftExpressionIbetaUnique
   {-# INLINE rule1078 #-}
   rule1078 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1079 #-}
   rule1079 = \ ((_leftExpressionIcollectErrors) :: TypeErrors) ->
     _leftExpressionIcollectErrors
   {-# INLINE rule1080 #-}
   rule1080 = \ ((_leftExpressionIcollectWarnings) :: Warnings) ->
     _leftExpressionIcollectWarnings
   {-# INLINE rule1081 #-}
   rule1081 = \ ((_leftExpressionIcounter) :: Int) ->
     _leftExpressionIcounter
   {-# INLINE rule1082 #-}
   rule1082 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1083 #-}
   rule1083 = \ ((_leftExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _leftExpressionIdictionaryEnvironment
   {-# INLINE rule1084 #-}
   rule1084 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1085 #-}
   rule1085 = \ ((_leftExpressionImatchIO) :: IO ()) ->
     _leftExpressionImatchIO
   {-# INLINE rule1086 #-}
   rule1086 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1087 #-}
   rule1087 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1088 #-}
   rule1088 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1089 #-}
   rule1089 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1090 #-}
   rule1090 = \ ((_leftExpressionIpatternMatchWarnings) :: [Warning]) ->
     _leftExpressionIpatternMatchWarnings
   {-# INLINE rule1091 #-}
   rule1091 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1092 #-}
   rule1092 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1093 #-}
   rule1093 = \ ((_leftExpressionIuniqueChunk) :: Int) ->
     _leftExpressionIuniqueChunk
   {-# INLINE rule1094 #-}
   rule1094 = \ ((_leftExpressionIuniqueSecondRound) :: Int) ->
     _leftExpressionIuniqueSecondRound
   {-# INLINE rule1095 #-}
   rule1095 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1096 #-}
   rule1096 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1097 #-}
   rule1097 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1098 #-}
   rule1098 = \ ((_operatorIbetaUnique) :: Int) ->
     _operatorIbetaUnique
   {-# INLINE rule1099 #-}
   rule1099 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1100 #-}
   rule1100 = \ ((_operatorIcollectErrors) :: TypeErrors) ->
     _operatorIcollectErrors
   {-# INLINE rule1101 #-}
   rule1101 = \ ((_operatorIcollectWarnings) :: Warnings) ->
     _operatorIcollectWarnings
   {-# INLINE rule1102 #-}
   rule1102 = \ ((_operatorIcounter) :: Int) ->
     _operatorIcounter
   {-# INLINE rule1103 #-}
   rule1103 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1104 #-}
   rule1104 = \ ((_operatorIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _operatorIdictionaryEnvironment
   {-# INLINE rule1105 #-}
   rule1105 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1106 #-}
   rule1106 = \ ((_operatorImatchIO) :: IO ()) ->
     _operatorImatchIO
   {-# INLINE rule1107 #-}
   rule1107 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1108 #-}
   rule1108 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1109 #-}
   rule1109 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1110 #-}
   rule1110 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1111 #-}
   rule1111 = \ ((_operatorIpatternMatchWarnings) :: [Warning]) ->
     _operatorIpatternMatchWarnings
   {-# INLINE rule1112 #-}
   rule1112 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1113 #-}
   rule1113 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1114 #-}
   rule1114 = \ ((_operatorIuniqueChunk) :: Int) ->
     _operatorIuniqueChunk
   {-# INLINE rule1115 #-}
   rule1115 = \ ((_operatorIuniqueSecondRound) :: Int) ->
     _operatorIuniqueSecondRound
{-# NOINLINE sem_Expression_If #-}
sem_Expression_If :: T_Range  -> T_Expression  -> T_Expression  -> T_Expression  -> T_Expression 
sem_Expression_If arg_range_ arg_guardExpression_ arg_thenExpression_ arg_elseExpression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _guardExpressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_guardExpression_))
         _thenExpressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_thenExpression_))
         _elseExpressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_elseExpression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _guardExpressionIassumptions _guardExpressionIbeta _guardExpressionIbetaUnique _guardExpressionIcollectErrors _guardExpressionIcollectInstances _guardExpressionIcollectWarnings _guardExpressionIconstraints _guardExpressionIcounter _guardExpressionIdictionaryEnvironment _guardExpressionIinfoTree _guardExpressionImatchIO _guardExpressionImatches _guardExpressionIpatternMatchWarnings _guardExpressionIself _guardExpressionIunboundNames _guardExpressionIuniqueChunk _guardExpressionIuniqueSecondRound) = inv_Expression_s41 _guardExpressionX41 (T_Expression_vIn40 _guardExpressionOallPatterns _guardExpressionOallTypeSchemes _guardExpressionOavailablePredicates _guardExpressionObetaUnique _guardExpressionOclassEnvironment _guardExpressionOcollectErrors _guardExpressionOcollectWarnings _guardExpressionOcounter _guardExpressionOcurrentChunk _guardExpressionOdictionaryEnvironment _guardExpressionOimportEnvironment _guardExpressionOmatchIO _guardExpressionOmonos _guardExpressionOnamesInScope _guardExpressionOorderedTypeSynonyms _guardExpressionOparentTree _guardExpressionOpatternMatchWarnings _guardExpressionOsubstitution _guardExpressionOtryPatterns _guardExpressionOtypeschemeMap _guardExpressionOuniqueChunk _guardExpressionOuniqueSecondRound)
         (T_Expression_vOut40 _thenExpressionIassumptions _thenExpressionIbeta _thenExpressionIbetaUnique _thenExpressionIcollectErrors _thenExpressionIcollectInstances _thenExpressionIcollectWarnings _thenExpressionIconstraints _thenExpressionIcounter _thenExpressionIdictionaryEnvironment _thenExpressionIinfoTree _thenExpressionImatchIO _thenExpressionImatches _thenExpressionIpatternMatchWarnings _thenExpressionIself _thenExpressionIunboundNames _thenExpressionIuniqueChunk _thenExpressionIuniqueSecondRound) = inv_Expression_s41 _thenExpressionX41 (T_Expression_vIn40 _thenExpressionOallPatterns _thenExpressionOallTypeSchemes _thenExpressionOavailablePredicates _thenExpressionObetaUnique _thenExpressionOclassEnvironment _thenExpressionOcollectErrors _thenExpressionOcollectWarnings _thenExpressionOcounter _thenExpressionOcurrentChunk _thenExpressionOdictionaryEnvironment _thenExpressionOimportEnvironment _thenExpressionOmatchIO _thenExpressionOmonos _thenExpressionOnamesInScope _thenExpressionOorderedTypeSynonyms _thenExpressionOparentTree _thenExpressionOpatternMatchWarnings _thenExpressionOsubstitution _thenExpressionOtryPatterns _thenExpressionOtypeschemeMap _thenExpressionOuniqueChunk _thenExpressionOuniqueSecondRound)
         (T_Expression_vOut40 _elseExpressionIassumptions _elseExpressionIbeta _elseExpressionIbetaUnique _elseExpressionIcollectErrors _elseExpressionIcollectInstances _elseExpressionIcollectWarnings _elseExpressionIconstraints _elseExpressionIcounter _elseExpressionIdictionaryEnvironment _elseExpressionIinfoTree _elseExpressionImatchIO _elseExpressionImatches _elseExpressionIpatternMatchWarnings _elseExpressionIself _elseExpressionIunboundNames _elseExpressionIuniqueChunk _elseExpressionIuniqueSecondRound) = inv_Expression_s41 _elseExpressionX41 (T_Expression_vIn40 _elseExpressionOallPatterns _elseExpressionOallTypeSchemes _elseExpressionOavailablePredicates _elseExpressionObetaUnique _elseExpressionOclassEnvironment _elseExpressionOcollectErrors _elseExpressionOcollectWarnings _elseExpressionOcounter _elseExpressionOcurrentChunk _elseExpressionOdictionaryEnvironment _elseExpressionOimportEnvironment _elseExpressionOmatchIO _elseExpressionOmonos _elseExpressionOnamesInScope _elseExpressionOorderedTypeSynonyms _elseExpressionOparentTree _elseExpressionOpatternMatchWarnings _elseExpressionOsubstitution _elseExpressionOtryPatterns _elseExpressionOtypeschemeMap _elseExpressionOuniqueChunk _elseExpressionOuniqueSecondRound)
         _guardExpressionObetaUnique = rule1116 _lhsIbetaUnique
         _assumptions = rule1117 _elseExpressionIassumptions _guardExpressionIassumptions _thenExpressionIassumptions
         _constraints = rule1118 _conElse _conGuard _conThen _elseExpressionIconstraints _guardExpressionIconstraints _thenExpressionIconstraints
         _beta = rule1119 _lhsIbetaUnique
         _conGuard = rule1120 _cinfoGuard _guardExpressionIbeta
         _conThen = rule1121 _beta _cinfoThen _thenExpressionIbeta
         _conElse = rule1122 _beta _cinfoElse _elseExpressionIbeta
         _cinfoGuard = rule1123 _parentTree
         _cinfoThen = rule1124 _beta _localInfo _parentTree
         _cinfoElse = rule1125 _beta _localInfo _parentTree
         _localInfo = rule1126 _beta _lhsImonos _self
         _parentTree = rule1127 _elseExpressionIinfoTree _guardExpressionIinfoTree _lhsIparentTree _localInfo _thenExpressionIinfoTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1128 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((_guardExpressionOtryPatterns,_thenExpressionOtryPatterns,_elseExpressionOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1129 _assumptions _constraints _elseExpressionImatches _elseExpressionIuniqueSecondRound _guardExpressionImatches _lhsIallPatterns _lhsItryPatterns _localInfo _thenExpressionImatches
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1130 _elseExpressionImatchIO _ioMatch
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1131 _elseExpressionIcollectInstances _guardExpressionIcollectInstances _thenExpressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1132 _elseExpressionIunboundNames _guardExpressionIunboundNames _thenExpressionIunboundNames
         _self = rule1133 _elseExpressionIself _guardExpressionIself _rangeIself _thenExpressionIself
         _lhsOself :: Expression
         _lhsOself = rule1134 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1135 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1136 _elseExpressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1137 _elseExpressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1138 _elseExpressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1139 _elseExpressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1140 _elseExpressionIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1141 _elseExpressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1142 _elseExpressionIuniqueChunk
         _guardExpressionOallPatterns = rule1143 _lhsIallPatterns
         _guardExpressionOallTypeSchemes = rule1144 _lhsIallTypeSchemes
         _guardExpressionOavailablePredicates = rule1145 _lhsIavailablePredicates
         _guardExpressionOclassEnvironment = rule1146 _lhsIclassEnvironment
         _guardExpressionOcollectErrors = rule1147 _lhsIcollectErrors
         _guardExpressionOcollectWarnings = rule1148 _lhsIcollectWarnings
         _guardExpressionOcounter = rule1149 _lhsIcounter
         _guardExpressionOcurrentChunk = rule1150 _lhsIcurrentChunk
         _guardExpressionOdictionaryEnvironment = rule1151 _lhsIdictionaryEnvironment
         _guardExpressionOimportEnvironment = rule1152 _lhsIimportEnvironment
         _guardExpressionOmatchIO = rule1153 _lhsImatchIO
         _guardExpressionOmonos = rule1154 _lhsImonos
         _guardExpressionOnamesInScope = rule1155 _lhsInamesInScope
         _guardExpressionOorderedTypeSynonyms = rule1156 _lhsIorderedTypeSynonyms
         _guardExpressionOparentTree = rule1157 _parentTree
         _guardExpressionOpatternMatchWarnings = rule1158 _lhsIpatternMatchWarnings
         _guardExpressionOsubstitution = rule1159 _lhsIsubstitution
         _guardExpressionOtypeschemeMap = rule1160 _lhsItypeschemeMap
         _guardExpressionOuniqueChunk = rule1161 _lhsIuniqueChunk
         _guardExpressionOuniqueSecondRound = rule1162 _lhsIuniqueSecondRound
         _thenExpressionOallPatterns = rule1163 _lhsIallPatterns
         _thenExpressionOallTypeSchemes = rule1164 _lhsIallTypeSchemes
         _thenExpressionOavailablePredicates = rule1165 _lhsIavailablePredicates
         _thenExpressionObetaUnique = rule1166 _guardExpressionIbetaUnique
         _thenExpressionOclassEnvironment = rule1167 _lhsIclassEnvironment
         _thenExpressionOcollectErrors = rule1168 _guardExpressionIcollectErrors
         _thenExpressionOcollectWarnings = rule1169 _guardExpressionIcollectWarnings
         _thenExpressionOcounter = rule1170 _guardExpressionIcounter
         _thenExpressionOcurrentChunk = rule1171 _lhsIcurrentChunk
         _thenExpressionOdictionaryEnvironment = rule1172 _guardExpressionIdictionaryEnvironment
         _thenExpressionOimportEnvironment = rule1173 _lhsIimportEnvironment
         _thenExpressionOmatchIO = rule1174 _guardExpressionImatchIO
         _thenExpressionOmonos = rule1175 _lhsImonos
         _thenExpressionOnamesInScope = rule1176 _lhsInamesInScope
         _thenExpressionOorderedTypeSynonyms = rule1177 _lhsIorderedTypeSynonyms
         _thenExpressionOparentTree = rule1178 _parentTree
         _thenExpressionOpatternMatchWarnings = rule1179 _guardExpressionIpatternMatchWarnings
         _thenExpressionOsubstitution = rule1180 _lhsIsubstitution
         _thenExpressionOtypeschemeMap = rule1181 _lhsItypeschemeMap
         _thenExpressionOuniqueChunk = rule1182 _guardExpressionIuniqueChunk
         _thenExpressionOuniqueSecondRound = rule1183 _guardExpressionIuniqueSecondRound
         _elseExpressionOallPatterns = rule1184 _lhsIallPatterns
         _elseExpressionOallTypeSchemes = rule1185 _lhsIallTypeSchemes
         _elseExpressionOavailablePredicates = rule1186 _lhsIavailablePredicates
         _elseExpressionObetaUnique = rule1187 _thenExpressionIbetaUnique
         _elseExpressionOclassEnvironment = rule1188 _lhsIclassEnvironment
         _elseExpressionOcollectErrors = rule1189 _thenExpressionIcollectErrors
         _elseExpressionOcollectWarnings = rule1190 _thenExpressionIcollectWarnings
         _elseExpressionOcounter = rule1191 _thenExpressionIcounter
         _elseExpressionOcurrentChunk = rule1192 _lhsIcurrentChunk
         _elseExpressionOdictionaryEnvironment = rule1193 _thenExpressionIdictionaryEnvironment
         _elseExpressionOimportEnvironment = rule1194 _lhsIimportEnvironment
         _elseExpressionOmatchIO = rule1195 _thenExpressionImatchIO
         _elseExpressionOmonos = rule1196 _lhsImonos
         _elseExpressionOnamesInScope = rule1197 _lhsInamesInScope
         _elseExpressionOorderedTypeSynonyms = rule1198 _lhsIorderedTypeSynonyms
         _elseExpressionOparentTree = rule1199 _parentTree
         _elseExpressionOpatternMatchWarnings = rule1200 _thenExpressionIpatternMatchWarnings
         _elseExpressionOsubstitution = rule1201 _lhsIsubstitution
         _elseExpressionOtypeschemeMap = rule1202 _lhsItypeschemeMap
         _elseExpressionOuniqueChunk = rule1203 _thenExpressionIuniqueChunk
         _elseExpressionOuniqueSecondRound = rule1204 _thenExpressionIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1116 #-}
   rule1116 = \ ((_lhsIbetaUnique) :: Int) ->
                                        _lhsIbetaUnique + 1
   {-# INLINE rule1117 #-}
   rule1117 = \ ((_elseExpressionIassumptions) :: Assumptions) ((_guardExpressionIassumptions) :: Assumptions) ((_thenExpressionIassumptions) :: Assumptions) ->
                                        _guardExpressionIassumptions `combine` _thenExpressionIassumptions `combine` _elseExpressionIassumptions
   {-# INLINE rule1118 #-}
   rule1118 = \ _conElse _conGuard _conThen ((_elseExpressionIconstraints) :: ConstraintSet) ((_guardExpressionIconstraints) :: ConstraintSet) ((_thenExpressionIconstraints) :: ConstraintSet) ->
                                        Node [ _conGuard .<. _guardExpressionIconstraints
                                             , _conThen  .<. _thenExpressionIconstraints
                                             , _conElse  .<. _elseExpressionIconstraints
                                             ]
   {-# INLINE rule1119 #-}
   rule1119 = \ ((_lhsIbetaUnique) :: Int) ->
                                        TVar _lhsIbetaUnique
   {-# INLINE rule1120 #-}
   rule1120 = \ _cinfoGuard ((_guardExpressionIbeta) :: Tp) ->
                                        [ (_guardExpressionIbeta .==. boolType) _cinfoGuard ]
   {-# INLINE rule1121 #-}
   rule1121 = \ _beta _cinfoThen ((_thenExpressionIbeta) :: Tp) ->
                                        [ (_thenExpressionIbeta  .==. _beta   ) _cinfoThen  ]
   {-# INLINE rule1122 #-}
   rule1122 = \ _beta _cinfoElse ((_elseExpressionIbeta) :: Tp) ->
                                        [ (_elseExpressionIbeta  .==. _beta   ) _cinfoElse  ]
   {-# INLINE rule1123 #-}
   rule1123 = \ _parentTree ->
     childConstraint 0 "conditional" _parentTree
        []
   {-# INLINE rule1124 #-}
   rule1124 = \ _beta _localInfo _parentTree ->
     childConstraint 1 "then branch of conditional" _parentTree
        [ Unifier (head (ftv _beta)) ("conditional", _localInfo, "then branch") ]
   {-# INLINE rule1125 #-}
   rule1125 = \ _beta _localInfo _parentTree ->
     childConstraint 2 "else branch of conditional" _parentTree
        [ Unifier (head (ftv _beta)) ("conditional", _localInfo, "else branch") ]
   {-# INLINE rule1126 #-}
   rule1126 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1127 #-}
   rule1127 = \ ((_elseExpressionIinfoTree) :: InfoTree) ((_guardExpressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_thenExpressionIinfoTree) :: InfoTree) ->
                            node _lhsIparentTree _localInfo [_guardExpressionIinfoTree, _thenExpressionIinfoTree, _elseExpressionIinfoTree]
   {-# INLINE rule1128 #-}
   rule1128 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1129 #-}
   rule1129 = \ _assumptions _constraints ((_elseExpressionImatches) :: [Maybe MetaVariableTable]) ((_elseExpressionIuniqueSecondRound) :: Int) ((_guardExpressionImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ((_thenExpressionImatches) :: [Maybe MetaVariableTable]) ->
             let infoTuple = metaVarInfo _constraints _assumptions _localInfo
             in match3 infoTuple _elseExpressionIuniqueSecondRound
                       match_Expression_If
                       _lhsItryPatterns _lhsIallPatterns
                       [_guardExpressionImatches,_thenExpressionImatches,_elseExpressionImatches]
   {-# INLINE rule1130 #-}
   rule1130 = \ ((_elseExpressionImatchIO) :: IO ()) _ioMatch ->
                                       _elseExpressionImatchIO  >> _ioMatch
   {-# INLINE rule1131 #-}
   rule1131 = \ ((_elseExpressionIcollectInstances) :: [(Name, Instance)]) ((_guardExpressionIcollectInstances) :: [(Name, Instance)]) ((_thenExpressionIcollectInstances) :: [(Name, Instance)]) ->
     _guardExpressionIcollectInstances  ++  _thenExpressionIcollectInstances  ++  _elseExpressionIcollectInstances
   {-# INLINE rule1132 #-}
   rule1132 = \ ((_elseExpressionIunboundNames) :: Names) ((_guardExpressionIunboundNames) :: Names) ((_thenExpressionIunboundNames) :: Names) ->
     _guardExpressionIunboundNames ++ _thenExpressionIunboundNames ++ _elseExpressionIunboundNames
   {-# INLINE rule1133 #-}
   rule1133 = \ ((_elseExpressionIself) :: Expression) ((_guardExpressionIself) :: Expression) ((_rangeIself) :: Range) ((_thenExpressionIself) :: Expression) ->
     Expression_If _rangeIself _guardExpressionIself _thenExpressionIself _elseExpressionIself
   {-# INLINE rule1134 #-}
   rule1134 = \ _self ->
     _self
   {-# INLINE rule1135 #-}
   rule1135 = \ _beta ->
     _beta
   {-# INLINE rule1136 #-}
   rule1136 = \ ((_elseExpressionIbetaUnique) :: Int) ->
     _elseExpressionIbetaUnique
   {-# INLINE rule1137 #-}
   rule1137 = \ ((_elseExpressionIcollectErrors) :: TypeErrors) ->
     _elseExpressionIcollectErrors
   {-# INLINE rule1138 #-}
   rule1138 = \ ((_elseExpressionIcollectWarnings) :: Warnings) ->
     _elseExpressionIcollectWarnings
   {-# INLINE rule1139 #-}
   rule1139 = \ ((_elseExpressionIcounter) :: Int) ->
     _elseExpressionIcounter
   {-# INLINE rule1140 #-}
   rule1140 = \ ((_elseExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _elseExpressionIdictionaryEnvironment
   {-# INLINE rule1141 #-}
   rule1141 = \ ((_elseExpressionIpatternMatchWarnings) :: [Warning]) ->
     _elseExpressionIpatternMatchWarnings
   {-# INLINE rule1142 #-}
   rule1142 = \ ((_elseExpressionIuniqueChunk) :: Int) ->
     _elseExpressionIuniqueChunk
   {-# INLINE rule1143 #-}
   rule1143 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1144 #-}
   rule1144 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1145 #-}
   rule1145 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1146 #-}
   rule1146 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1147 #-}
   rule1147 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1148 #-}
   rule1148 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1149 #-}
   rule1149 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1150 #-}
   rule1150 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1151 #-}
   rule1151 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1152 #-}
   rule1152 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1153 #-}
   rule1153 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1154 #-}
   rule1154 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1155 #-}
   rule1155 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1156 #-}
   rule1156 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1157 #-}
   rule1157 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1158 #-}
   rule1158 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1159 #-}
   rule1159 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1160 #-}
   rule1160 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1161 #-}
   rule1161 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1162 #-}
   rule1162 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1163 #-}
   rule1163 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1164 #-}
   rule1164 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1165 #-}
   rule1165 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1166 #-}
   rule1166 = \ ((_guardExpressionIbetaUnique) :: Int) ->
     _guardExpressionIbetaUnique
   {-# INLINE rule1167 #-}
   rule1167 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1168 #-}
   rule1168 = \ ((_guardExpressionIcollectErrors) :: TypeErrors) ->
     _guardExpressionIcollectErrors
   {-# INLINE rule1169 #-}
   rule1169 = \ ((_guardExpressionIcollectWarnings) :: Warnings) ->
     _guardExpressionIcollectWarnings
   {-# INLINE rule1170 #-}
   rule1170 = \ ((_guardExpressionIcounter) :: Int) ->
     _guardExpressionIcounter
   {-# INLINE rule1171 #-}
   rule1171 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1172 #-}
   rule1172 = \ ((_guardExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _guardExpressionIdictionaryEnvironment
   {-# INLINE rule1173 #-}
   rule1173 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1174 #-}
   rule1174 = \ ((_guardExpressionImatchIO) :: IO ()) ->
     _guardExpressionImatchIO
   {-# INLINE rule1175 #-}
   rule1175 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1176 #-}
   rule1176 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1177 #-}
   rule1177 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1178 #-}
   rule1178 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1179 #-}
   rule1179 = \ ((_guardExpressionIpatternMatchWarnings) :: [Warning]) ->
     _guardExpressionIpatternMatchWarnings
   {-# INLINE rule1180 #-}
   rule1180 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1181 #-}
   rule1181 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1182 #-}
   rule1182 = \ ((_guardExpressionIuniqueChunk) :: Int) ->
     _guardExpressionIuniqueChunk
   {-# INLINE rule1183 #-}
   rule1183 = \ ((_guardExpressionIuniqueSecondRound) :: Int) ->
     _guardExpressionIuniqueSecondRound
   {-# INLINE rule1184 #-}
   rule1184 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1185 #-}
   rule1185 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1186 #-}
   rule1186 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1187 #-}
   rule1187 = \ ((_thenExpressionIbetaUnique) :: Int) ->
     _thenExpressionIbetaUnique
   {-# INLINE rule1188 #-}
   rule1188 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1189 #-}
   rule1189 = \ ((_thenExpressionIcollectErrors) :: TypeErrors) ->
     _thenExpressionIcollectErrors
   {-# INLINE rule1190 #-}
   rule1190 = \ ((_thenExpressionIcollectWarnings) :: Warnings) ->
     _thenExpressionIcollectWarnings
   {-# INLINE rule1191 #-}
   rule1191 = \ ((_thenExpressionIcounter) :: Int) ->
     _thenExpressionIcounter
   {-# INLINE rule1192 #-}
   rule1192 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1193 #-}
   rule1193 = \ ((_thenExpressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _thenExpressionIdictionaryEnvironment
   {-# INLINE rule1194 #-}
   rule1194 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1195 #-}
   rule1195 = \ ((_thenExpressionImatchIO) :: IO ()) ->
     _thenExpressionImatchIO
   {-# INLINE rule1196 #-}
   rule1196 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1197 #-}
   rule1197 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1198 #-}
   rule1198 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1199 #-}
   rule1199 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1200 #-}
   rule1200 = \ ((_thenExpressionIpatternMatchWarnings) :: [Warning]) ->
     _thenExpressionIpatternMatchWarnings
   {-# INLINE rule1201 #-}
   rule1201 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1202 #-}
   rule1202 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1203 #-}
   rule1203 = \ ((_thenExpressionIuniqueChunk) :: Int) ->
     _thenExpressionIuniqueChunk
   {-# INLINE rule1204 #-}
   rule1204 = \ ((_thenExpressionIuniqueSecondRound) :: Int) ->
     _thenExpressionIuniqueSecondRound
{-# NOINLINE sem_Expression_Lambda #-}
sem_Expression_Lambda :: T_Range  -> T_Patterns  -> T_Expression  -> T_Expression 
sem_Expression_Lambda arg_range_ arg_patterns_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _patternsObetaUnique = rule1205 _lhsIbetaUnique
         _expressionOmonos = rule1206 _csetBinds _lhsImonos _patternsIenvironment
         _constraints = rule1207 _csetBinds _expressionIconstraints _newcon _patternsIconstraintslist
         _beta = rule1208 _lhsIbetaUnique
         _newcon = rule1209 _beta _cinfoType _expressionIbeta _patternsIbetas
         (_csetBinds,_assumptions) = rule1210 _cinfoBind _expressionIassumptions _patternsIenvironment
         _cinfoBind = rule1211 _parentTree _patternsIenvironment
         _cinfoType = rule1212 _parentTree
         _localInfo = rule1213 _beta _lhsImonos _self
         _parentTree = rule1214 _expressionIinfoTree _lhsIparentTree _localInfo _patternsIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1215 _parentTree
         (_namesInScope,_unboundNames,_scopeInfo) = rule1216 _expressionIunboundNames _lhsInamesInScope _patternsIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1217 _unboundNames
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1218 _assumptions _constraints _lhsItryPatterns _localInfo
         _expressionOtryPatterns = rule1219  ()
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1220 _beta _expressionIpatternMatchWarnings _lhsIimportEnvironment _lhsIsubstitution _patternsIelementss _patternsIself _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1221 _expressionIcollectInstances
         _self = rule1222 _expressionIself _patternsIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1223 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1224 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1225 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1226 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1227 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1228 _expressionIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1229 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1230 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1231 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1232 _expressionImatchIO
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1233 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1234 _expressionIuniqueSecondRound
         _patternsOcounter = rule1235 _lhsIcounter
         _patternsOimportEnvironment = rule1236 _lhsIimportEnvironment
         _patternsOmonos = rule1237 _lhsImonos
         _patternsOnamesInScope = rule1238 _namesInScope
         _patternsOparentTree = rule1239 _parentTree
         _patternsOpatternMatchWarnings = rule1240 _lhsIpatternMatchWarnings
         _expressionOallPatterns = rule1241 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1242 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1243 _lhsIavailablePredicates
         _expressionObetaUnique = rule1244 _patternsIbetaUnique
         _expressionOclassEnvironment = rule1245 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1246 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1247 _lhsIcollectWarnings
         _expressionOcounter = rule1248 _patternsIcounter
         _expressionOcurrentChunk = rule1249 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1250 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1251 _lhsIimportEnvironment
         _expressionOmatchIO = rule1252 _lhsImatchIO
         _expressionOnamesInScope = rule1253 _namesInScope
         _expressionOorderedTypeSynonyms = rule1254 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1255 _parentTree
         _expressionOpatternMatchWarnings = rule1256 _patternsIpatternMatchWarnings
         _expressionOsubstitution = rule1257 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1258 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1259 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1260 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1205 #-}
   rule1205 = \ ((_lhsIbetaUnique) :: Int) ->
                                   _lhsIbetaUnique + 1
   {-# INLINE rule1206 #-}
   rule1206 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternsIenvironment) :: PatternAssumptions) ->
                                   M.elems _patternsIenvironment ++ getMonos _csetBinds ++ _lhsImonos
   {-# INLINE rule1207 #-}
   rule1207 = \ _csetBinds ((_expressionIconstraints) :: ConstraintSet) _newcon ((_patternsIconstraintslist) :: ConstraintSets) ->
                                   _newcon .>. _csetBinds .>>.
                                   Node [ Node _patternsIconstraintslist
                                        , _expressionIconstraints
                                        ]
   {-# INLINE rule1208 #-}
   rule1208 = \ ((_lhsIbetaUnique) :: Int) ->
                                   TVar _lhsIbetaUnique
   {-# INLINE rule1209 #-}
   rule1209 = \ _beta _cinfoType ((_expressionIbeta) :: Tp) ((_patternsIbetas) :: Tps) ->
                                   [ (foldr (.->.) _expressionIbeta _patternsIbetas .==. _beta) _cinfoType ]
   {-# INLINE rule1210 #-}
   rule1210 = \ _cinfoBind ((_expressionIassumptions) :: Assumptions) ((_patternsIenvironment) :: PatternAssumptions) ->
                                           (_patternsIenvironment .===. _expressionIassumptions) _cinfoBind
   {-# INLINE rule1211 #-}
   rule1211 = \ _parentTree ((_patternsIenvironment) :: PatternAssumptions) ->
     \name -> variableConstraint "variable" (nameToUHA_Expr name)
        [ FolkloreConstraint
        , makeUnifier name "lambda abstraction" _patternsIenvironment _parentTree
        ]
   {-# INLINE rule1212 #-}
   rule1212 = \ _parentTree ->
     resultConstraint "lambda abstraction" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule1213 #-}
   rule1213 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1214 #-}
   rule1214 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo (_patternsIinfoTrees ++ [_expressionIinfoTree])
   {-# INLINE rule1215 #-}
   rule1215 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1216 #-}
   rule1216 = \ ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_patternsIpatVarNames) :: Names) ->
                                                                        changeOfScope _patternsIpatVarNames _expressionIunboundNames _lhsInamesInScope
   {-# INLINE rule1217 #-}
   rule1217 = \ _unboundNames ->
                                             _unboundNames
   {-# INLINE rule1218 #-}
   rule1218 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in matchOnlyVariable infoTuple _lhsItryPatterns
   {-# INLINE rule1219 #-}
   rule1219 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule1220 #-}
   rule1220 = \ _beta ((_expressionIpatternMatchWarnings) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternsIelementss) :: [ [PatternElement]       ]) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
                                                    patternMatchWarnings _lhsIimportEnvironment
                                                                         _lhsIsubstitution
                                                                         _beta
                                                                         (take (length _patternsIself) . fst . functionSpine)
                                                                         [(concat _patternsIelementss, False)]
                                                                         _rangeIself
                                                                         (Just $ Name_Special noRange [] "\\")
                                                                         True
                                                                         []
                                                                         "lambda expression"
                                                                         "->"
                                                    ++ _expressionIpatternMatchWarnings
   {-# INLINE rule1221 #-}
   rule1221 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule1222 #-}
   rule1222 = \ ((_expressionIself) :: Expression) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
     Expression_Lambda _rangeIself _patternsIself _expressionIself
   {-# INLINE rule1223 #-}
   rule1223 = \ _self ->
     _self
   {-# INLINE rule1224 #-}
   rule1224 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1225 #-}
   rule1225 = \ _beta ->
     _beta
   {-# INLINE rule1226 #-}
   rule1226 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1227 #-}
   rule1227 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1228 #-}
   rule1228 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1229 #-}
   rule1229 = \ _constraints ->
     _constraints
   {-# INLINE rule1230 #-}
   rule1230 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1231 #-}
   rule1231 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1232 #-}
   rule1232 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule1233 #-}
   rule1233 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule1234 #-}
   rule1234 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule1235 #-}
   rule1235 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1236 #-}
   rule1236 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1237 #-}
   rule1237 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1238 #-}
   rule1238 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule1239 #-}
   rule1239 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1240 #-}
   rule1240 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1241 #-}
   rule1241 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1242 #-}
   rule1242 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1243 #-}
   rule1243 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1244 #-}
   rule1244 = \ ((_patternsIbetaUnique) :: Int) ->
     _patternsIbetaUnique
   {-# INLINE rule1245 #-}
   rule1245 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1246 #-}
   rule1246 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1247 #-}
   rule1247 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1248 #-}
   rule1248 = \ ((_patternsIcounter) :: Int) ->
     _patternsIcounter
   {-# INLINE rule1249 #-}
   rule1249 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1250 #-}
   rule1250 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1251 #-}
   rule1251 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1252 #-}
   rule1252 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1253 #-}
   rule1253 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule1254 #-}
   rule1254 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1255 #-}
   rule1255 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1256 #-}
   rule1256 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
     _patternsIpatternMatchWarnings
   {-# INLINE rule1257 #-}
   rule1257 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1258 #-}
   rule1258 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1259 #-}
   rule1259 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1260 #-}
   rule1260 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Case #-}
sem_Expression_Case :: T_Range  -> T_Expression  -> T_Alternatives  -> T_Expression 
sem_Expression_Case arg_range_ arg_expression_ arg_alternatives_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         _alternativesX5 = Control.Monad.Identity.runIdentity (attach_T_Alternatives (arg_alternatives_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         (T_Alternatives_vOut4 _alternativesIassumptions _alternativesIbetaUnique _alternativesIcollectErrors _alternativesIcollectInstances _alternativesIcollectWarnings _alternativesIconstraintslist _alternativesIcounter _alternativesIdictionaryEnvironment _alternativesIelementss _alternativesIinfoTrees _alternativesImatchIO _alternativesIpatternMatchWarnings _alternativesIself _alternativesIunboundNames _alternativesIuniqueChunk _alternativesIunrwars) = inv_Alternatives_s5 _alternativesX5 (T_Alternatives_vIn4 _alternativesOallPatterns _alternativesOallTypeSchemes _alternativesOavailablePredicates _alternativesObetaLeft _alternativesObetaRight _alternativesObetaUnique _alternativesOclassEnvironment _alternativesOcollectErrors _alternativesOcollectWarnings _alternativesOcounter _alternativesOcurrentChunk _alternativesOdictionaryEnvironment _alternativesOimportEnvironment _alternativesOmatchIO _alternativesOmonos _alternativesOnamesInScope _alternativesOorderedTypeSynonyms _alternativesOparentTree _alternativesOpatternMatchWarnings _alternativesOsubstitution _alternativesOtypeschemeMap _alternativesOuniqueChunk)
         _expressionObetaUnique = rule1261 _lhsIbetaUnique
         _alternativesObetaLeft = rule1262 _beta'
         _alternativesObetaRight = rule1263 _beta
         _assumptions = rule1264 _alternativesIassumptions _expressionIassumptions
         _constraints = rule1265 _alternativesIconstraintslist _expressionIconstraints _newcon
         _beta = rule1266 _lhsIbetaUnique
         _beta' = rule1267 _lhsIbetaUnique
         _newcon = rule1268 _beta' _cinfo _expressionIbeta
         _cinfo = rule1269 _beta' _localInfo _parentTree
         _localInfo = rule1270 _beta _lhsImonos _self
         _parentTree = rule1271 _alternativesIinfoTrees _expressionIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1272 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1273 _assumptions _constraints _lhsItryPatterns _localInfo
         _expressionOtryPatterns = rule1274  ()
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1275 _alternativesIelementss _alternativesIpatternMatchWarnings _alternativesIunrwars _expressionIbeta _lhsIimportEnvironment _lhsIsubstitution _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1276 _alternativesIcollectInstances _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1277 _alternativesIunboundNames _expressionIunboundNames
         _self = rule1278 _alternativesIself _expressionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1279 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1280 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1281 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1282 _alternativesIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1283 _alternativesIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1284 _alternativesIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1285 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1286 _alternativesIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1287 _alternativesIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1288 _alternativesImatchIO
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1289 _alternativesIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1290 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule1291 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1292 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1293 _lhsIavailablePredicates
         _expressionOclassEnvironment = rule1294 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1295 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1296 _lhsIcollectWarnings
         _expressionOcounter = rule1297 _lhsIcounter
         _expressionOcurrentChunk = rule1298 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1299 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1300 _lhsIimportEnvironment
         _expressionOmatchIO = rule1301 _lhsImatchIO
         _expressionOmonos = rule1302 _lhsImonos
         _expressionOnamesInScope = rule1303 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule1304 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1305 _parentTree
         _expressionOpatternMatchWarnings = rule1306 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule1307 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1308 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1309 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1310 _lhsIuniqueSecondRound
         _alternativesOallPatterns = rule1311 _lhsIallPatterns
         _alternativesOallTypeSchemes = rule1312 _lhsIallTypeSchemes
         _alternativesOavailablePredicates = rule1313 _lhsIavailablePredicates
         _alternativesObetaUnique = rule1314 _expressionIbetaUnique
         _alternativesOclassEnvironment = rule1315 _lhsIclassEnvironment
         _alternativesOcollectErrors = rule1316 _expressionIcollectErrors
         _alternativesOcollectWarnings = rule1317 _expressionIcollectWarnings
         _alternativesOcounter = rule1318 _expressionIcounter
         _alternativesOcurrentChunk = rule1319 _lhsIcurrentChunk
         _alternativesOdictionaryEnvironment = rule1320 _expressionIdictionaryEnvironment
         _alternativesOimportEnvironment = rule1321 _lhsIimportEnvironment
         _alternativesOmatchIO = rule1322 _expressionImatchIO
         _alternativesOmonos = rule1323 _lhsImonos
         _alternativesOnamesInScope = rule1324 _lhsInamesInScope
         _alternativesOorderedTypeSynonyms = rule1325 _lhsIorderedTypeSynonyms
         _alternativesOparentTree = rule1326 _parentTree
         _alternativesOpatternMatchWarnings = rule1327 _expressionIpatternMatchWarnings
         _alternativesOsubstitution = rule1328 _lhsIsubstitution
         _alternativesOtypeschemeMap = rule1329 _lhsItypeschemeMap
         _alternativesOuniqueChunk = rule1330 _expressionIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1261 #-}
   rule1261 = \ ((_lhsIbetaUnique) :: Int) ->
                                     _lhsIbetaUnique + 2
   {-# INLINE rule1262 #-}
   rule1262 = \ _beta' ->
                                     _beta'
   {-# INLINE rule1263 #-}
   rule1263 = \ _beta ->
                                     _beta
   {-# INLINE rule1264 #-}
   rule1264 = \ ((_alternativesIassumptions) :: Assumptions) ((_expressionIassumptions) :: Assumptions) ->
                                     _expressionIassumptions `combine` _alternativesIassumptions
   {-# INLINE rule1265 #-}
   rule1265 = \ ((_alternativesIconstraintslist) :: ConstraintSets) ((_expressionIconstraints) :: ConstraintSet) _newcon ->
                                     Node [ _newcon .<. _expressionIconstraints
                                          , Node _alternativesIconstraintslist
                                          ]
   {-# INLINE rule1266 #-}
   rule1266 = \ ((_lhsIbetaUnique) :: Int) ->
                                     TVar _lhsIbetaUnique
   {-# INLINE rule1267 #-}
   rule1267 = \ ((_lhsIbetaUnique) :: Int) ->
                                     TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule1268 #-}
   rule1268 = \ _beta' _cinfo ((_expressionIbeta) :: Tp) ->
                                     [ (_expressionIbeta .==. _beta') _cinfo ]
   {-# INLINE rule1269 #-}
   rule1269 = \ _beta' _localInfo _parentTree ->
     childConstraint 0 "scrutinee of case expression" _parentTree
        [ Unifier (head (ftv _beta')) ("case patterns", _localInfo, "scrutinee") ]
   {-# INLINE rule1270 #-}
   rule1270 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1271 #-}
   rule1271 = \ ((_alternativesIinfoTrees) :: InfoTrees) ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo (_expressionIinfoTree : _alternativesIinfoTrees)
   {-# INLINE rule1272 #-}
   rule1272 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1273 #-}
   rule1273 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in matchOnlyVariable infoTuple _lhsItryPatterns
   {-# INLINE rule1274 #-}
   rule1274 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule1275 #-}
   rule1275 = \ ((_alternativesIelementss) :: [([PatternElement], Bool)]) ((_alternativesIpatternMatchWarnings) :: [Warning]) ((_alternativesIunrwars) :: [Warning]) ((_expressionIbeta) :: Tp) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_rangeIself) :: Range) ->
                                                    patternMatchWarnings _lhsIimportEnvironment
                                                                         _lhsIsubstitution
                                                                         _expressionIbeta
                                                                         (:[])
                                                                         _alternativesIelementss
                                                                         _rangeIself
                                                                         Nothing
                                                                         False
                                                                         _alternativesIunrwars
                                                                         "case expression"
                                                                         "->"
                                                    ++ _alternativesIpatternMatchWarnings
   {-# INLINE rule1276 #-}
   rule1276 = \ ((_alternativesIcollectInstances) :: [(Name, Instance)]) ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances  ++  _alternativesIcollectInstances
   {-# INLINE rule1277 #-}
   rule1277 = \ ((_alternativesIunboundNames) :: Names) ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames ++ _alternativesIunboundNames
   {-# INLINE rule1278 #-}
   rule1278 = \ ((_alternativesIself) :: Alternatives) ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_Case _rangeIself _expressionIself _alternativesIself
   {-# INLINE rule1279 #-}
   rule1279 = \ _self ->
     _self
   {-# INLINE rule1280 #-}
   rule1280 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1281 #-}
   rule1281 = \ _beta ->
     _beta
   {-# INLINE rule1282 #-}
   rule1282 = \ ((_alternativesIbetaUnique) :: Int) ->
     _alternativesIbetaUnique
   {-# INLINE rule1283 #-}
   rule1283 = \ ((_alternativesIcollectErrors) :: TypeErrors) ->
     _alternativesIcollectErrors
   {-# INLINE rule1284 #-}
   rule1284 = \ ((_alternativesIcollectWarnings) :: Warnings) ->
     _alternativesIcollectWarnings
   {-# INLINE rule1285 #-}
   rule1285 = \ _constraints ->
     _constraints
   {-# INLINE rule1286 #-}
   rule1286 = \ ((_alternativesIcounter) :: Int) ->
     _alternativesIcounter
   {-# INLINE rule1287 #-}
   rule1287 = \ ((_alternativesIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _alternativesIdictionaryEnvironment
   {-# INLINE rule1288 #-}
   rule1288 = \ ((_alternativesImatchIO) :: IO ()) ->
     _alternativesImatchIO
   {-# INLINE rule1289 #-}
   rule1289 = \ ((_alternativesIuniqueChunk) :: Int) ->
     _alternativesIuniqueChunk
   {-# INLINE rule1290 #-}
   rule1290 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule1291 #-}
   rule1291 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1292 #-}
   rule1292 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1293 #-}
   rule1293 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1294 #-}
   rule1294 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1295 #-}
   rule1295 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1296 #-}
   rule1296 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1297 #-}
   rule1297 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1298 #-}
   rule1298 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1299 #-}
   rule1299 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1300 #-}
   rule1300 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1301 #-}
   rule1301 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1302 #-}
   rule1302 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1303 #-}
   rule1303 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1304 #-}
   rule1304 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1305 #-}
   rule1305 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1306 #-}
   rule1306 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1307 #-}
   rule1307 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1308 #-}
   rule1308 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1309 #-}
   rule1309 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1310 #-}
   rule1310 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1311 #-}
   rule1311 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1312 #-}
   rule1312 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1313 #-}
   rule1313 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1314 #-}
   rule1314 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1315 #-}
   rule1315 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1316 #-}
   rule1316 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1317 #-}
   rule1317 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1318 #-}
   rule1318 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1319 #-}
   rule1319 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1320 #-}
   rule1320 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1321 #-}
   rule1321 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1322 #-}
   rule1322 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule1323 #-}
   rule1323 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1324 #-}
   rule1324 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1325 #-}
   rule1325 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1326 #-}
   rule1326 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1327 #-}
   rule1327 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1328 #-}
   rule1328 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1329 #-}
   rule1329 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1330 #-}
   rule1330 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
{-# NOINLINE sem_Expression_Let #-}
sem_Expression_Let :: T_Range  -> T_Declarations  -> T_Expression  -> T_Expression 
sem_Expression_Let arg_range_ arg_declarations_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _declarationsObetaUnique = rule1331 _lhsIbetaUnique
         _declarationsObindingGroups = rule1332  ()
         _constraints = rule1333 _beta _cinfoType _cset _expressionIbeta
         _beta = rule1334 _lhsIbetaUnique
         _lhsObetaUnique :: Int
         (_assumptions,_cset,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule1335 _declarationsIbindingGroups _declarationsItypeSignatures _expressionIassumptions _expressionIbetaUnique _expressionIconstraints _expressionIuniqueChunk _lhsIcurrentChunk _lhsImonos
         _inferredTypes = rule1336 _implicitsFM _lhsItypeschemeMap
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1337 _declarationsIsimplePatNames _expressionIcollectWarnings _inferredTypes
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1338 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
         _allTypeSchemes = rule1339 _lhsIallTypeSchemes _localTypes
         _localTypes = rule1340 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
         _declarationsOtypeSignatures = rule1341  ()
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1342 _chunkNr
         _cinfoType = rule1343 _thisTree
         _localInfo = rule1344 _beta _lhsImonos _self
         _declInfo = rule1345 _declarationsIself _lhsImonos
         _thisTree = rule1346 _declTree _expressionIinfoTree _lhsIparentTree _localInfo
         _declTree = rule1347 _declInfo _declarationsIinfoTrees _thisTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1348 _thisTree
         _expressionOparentTree = rule1349 _thisTree
         _declarationsOparentTree = rule1350 _declTree
         (_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule1351  ()
         (_namesInScope,_unboundNames,_scopeInfo) = rule1352 _declarationsIdeclVarNames _declarationsIunboundNames _expressionIunboundNames _lhsInamesInScope
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1353 _unboundNames
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1354 _assumptions _constraints _lhsItryPatterns _localInfo
         _expressionOtryPatterns = rule1355  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1356 _declarationsIcollectInstances _expressionIcollectInstances
         _self = rule1357 _declarationsIself _expressionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1358 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1359 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1360 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1361 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1362 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1363 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1364 _expressionImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1365 _expressionIpatternMatchWarnings
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1366 _expressionIuniqueSecondRound
         _declarationsOallPatterns = rule1367 _lhsIallPatterns
         _declarationsOallTypeSchemes = rule1368 _allTypeSchemes
         _declarationsOavailablePredicates = rule1369 _lhsIavailablePredicates
         _declarationsOclassEnvironment = rule1370 _lhsIclassEnvironment
         _declarationsOcollectErrors = rule1371 _lhsIcollectErrors
         _declarationsOcollectWarnings = rule1372 _lhsIcollectWarnings
         _declarationsOcounter = rule1373 _lhsIcounter
         _declarationsOcurrentChunk = rule1374 _lhsIcurrentChunk
         _declarationsOdictionaryEnvironment = rule1375 _lhsIdictionaryEnvironment
         _declarationsOimportEnvironment = rule1376 _lhsIimportEnvironment
         _declarationsOinheritedBDG = rule1377 _inheritedBDG
         _declarationsOmatchIO = rule1378 _lhsImatchIO
         _declarationsOmonos = rule1379 _lhsImonos
         _declarationsOnamesInScope = rule1380 _namesInScope
         _declarationsOorderedTypeSynonyms = rule1381 _lhsIorderedTypeSynonyms
         _declarationsOpatternMatchWarnings = rule1382 _lhsIpatternMatchWarnings
         _declarationsOsubstitution = rule1383 _lhsIsubstitution
         _declarationsOtypeschemeMap = rule1384 _lhsItypeschemeMap
         _declarationsOuniqueChunk = rule1385 _lhsIuniqueChunk
         _expressionOallPatterns = rule1386 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1387 _allTypeSchemes
         _expressionOavailablePredicates = rule1388 _lhsIavailablePredicates
         _expressionObetaUnique = rule1389 _declarationsIbetaUnique
         _expressionOclassEnvironment = rule1390 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1391 _declarationsIcollectErrors
         _expressionOcollectWarnings = rule1392 _declarationsIcollectWarnings
         _expressionOcounter = rule1393 _declarationsIcounter
         _expressionOcurrentChunk = rule1394 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1395 _declarationsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1396 _lhsIimportEnvironment
         _expressionOmatchIO = rule1397 _declarationsImatchIO
         _expressionOmonos = rule1398 _lhsImonos
         _expressionOnamesInScope = rule1399 _namesInScope
         _expressionOorderedTypeSynonyms = rule1400 _lhsIorderedTypeSynonyms
         _expressionOpatternMatchWarnings = rule1401 _declarationsIpatternMatchWarnings
         _expressionOsubstitution = rule1402 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1403 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1404 _declarationsIuniqueChunk
         _expressionOuniqueSecondRound = rule1405 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1331 #-}
   rule1331 = \ ((_lhsIbetaUnique) :: Int) ->
                                        _lhsIbetaUnique + 1
   {-# INLINE rule1332 #-}
   rule1332 = \  (_ :: ()) ->
                                        []
   {-# INLINE rule1333 #-}
   rule1333 = \ _beta _cinfoType _cset ((_expressionIbeta) :: Tp) ->
                                        [ (_expressionIbeta .==. _beta) _cinfoType ] .>. _cset
   {-# INLINE rule1334 #-}
   rule1334 = \ ((_lhsIbetaUnique) :: Int) ->
                                        TVar _lhsIbetaUnique
   {-# INLINE rule1335 #-}
   rule1335 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_expressionIassumptions) :: Assumptions) ((_expressionIbetaUnique) :: Int) ((_expressionIconstraints) :: ConstraintSet) ((_expressionIuniqueChunk) :: Int) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
           let inputBDG   = (False, _lhsIcurrentChunk, _expressionIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _expressionIbetaUnique)
               mybdggroup = Just (_expressionIassumptions, [_expressionIconstraints])
           in performBindingGroup inputBDG _declarationsIbindingGroups
   {-# INLINE rule1336 #-}
   rule1336 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
                                        findInferredTypes _lhsItypeschemeMap _implicitsFM
   {-# INLINE rule1337 #-}
   rule1337 = \ ((_declarationsIsimplePatNames) :: Names) ((_expressionIcollectWarnings) :: Warnings) _inferredTypes ->
                                        missingTypeSignature False _declarationsIsimplePatNames  _inferredTypes
                                        ++ _expressionIcollectWarnings
   {-# INLINE rule1338 #-}
   rule1338 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
                                        restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
                                        ++ _declarationsIcollectErrors
   {-# INLINE rule1339 #-}
   rule1339 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
                                    _localTypes `M.union` _lhsIallTypeSchemes
   {-# INLINE rule1340 #-}
   rule1340 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
                                    makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
   {-# INLINE rule1341 #-}
   rule1341 = \  (_ :: ()) ->
                                                                  M.empty
   {-# INLINE rule1342 #-}
   rule1342 = \ _chunkNr ->
                                                     _chunkNr
   {-# INLINE rule1343 #-}
   rule1343 = \ _thisTree ->
     resultConstraint "let expression (INTERNAL ERROR)" _thisTree
        [ FolkloreConstraint, highlyTrusted ]
   {-# INLINE rule1344 #-}
   rule1344 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1345 #-}
   rule1345 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
                          LocalInfo { self = UHA_Decls _declarationsIself
                                    , assignedType = Nothing
                                    , monos = _lhsImonos
                                    }
   {-# INLINE rule1346 #-}
   rule1346 = \ _declTree ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_declTree, _expressionIinfoTree]
   {-# INLINE rule1347 #-}
   rule1347 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) _thisTree ->
                            node _thisTree _declInfo _declarationsIinfoTrees
   {-# INLINE rule1348 #-}
   rule1348 = \ _thisTree ->
                            _thisTree
   {-# INLINE rule1349 #-}
   rule1349 = \ _thisTree ->
                                     _thisTree
   {-# INLINE rule1350 #-}
   rule1350 = \ _declTree ->
                                     _declTree
   {-# INLINE rule1351 #-}
   rule1351 = \  (_ :: ()) ->
                                                                                                                                                   internalError "PartialSyntax.ag" "n/a" "toplevel Expression"
   {-# INLINE rule1352 #-}
   rule1352 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ->
                                                             changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _expressionIunboundNames) _lhsInamesInScope
   {-# INLINE rule1353 #-}
   rule1353 = \ _unboundNames ->
                                  _unboundNames
   {-# INLINE rule1354 #-}
   rule1354 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in matchOnlyVariable infoTuple _lhsItryPatterns
   {-# INLINE rule1355 #-}
   rule1355 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule1356 #-}
   rule1356 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _declarationsIcollectInstances  ++  _expressionIcollectInstances
   {-# INLINE rule1357 #-}
   rule1357 = \ ((_declarationsIself) :: Declarations) ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_Let _rangeIself _declarationsIself _expressionIself
   {-# INLINE rule1358 #-}
   rule1358 = \ _self ->
     _self
   {-# INLINE rule1359 #-}
   rule1359 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1360 #-}
   rule1360 = \ _beta ->
     _beta
   {-# INLINE rule1361 #-}
   rule1361 = \ _constraints ->
     _constraints
   {-# INLINE rule1362 #-}
   rule1362 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1363 #-}
   rule1363 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1364 #-}
   rule1364 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule1365 #-}
   rule1365 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1366 #-}
   rule1366 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule1367 #-}
   rule1367 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1368 #-}
   rule1368 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule1369 #-}
   rule1369 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1370 #-}
   rule1370 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1371 #-}
   rule1371 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1372 #-}
   rule1372 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1373 #-}
   rule1373 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1374 #-}
   rule1374 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1375 #-}
   rule1375 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1376 #-}
   rule1376 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1377 #-}
   rule1377 = \ _inheritedBDG ->
     _inheritedBDG
   {-# INLINE rule1378 #-}
   rule1378 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1379 #-}
   rule1379 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1380 #-}
   rule1380 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule1381 #-}
   rule1381 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1382 #-}
   rule1382 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1383 #-}
   rule1383 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1384 #-}
   rule1384 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1385 #-}
   rule1385 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1386 #-}
   rule1386 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1387 #-}
   rule1387 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule1388 #-}
   rule1388 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1389 #-}
   rule1389 = \ ((_declarationsIbetaUnique) :: Int) ->
     _declarationsIbetaUnique
   {-# INLINE rule1390 #-}
   rule1390 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1391 #-}
   rule1391 = \ ((_declarationsIcollectErrors) :: TypeErrors) ->
     _declarationsIcollectErrors
   {-# INLINE rule1392 #-}
   rule1392 = \ ((_declarationsIcollectWarnings) :: Warnings) ->
     _declarationsIcollectWarnings
   {-# INLINE rule1393 #-}
   rule1393 = \ ((_declarationsIcounter) :: Int) ->
     _declarationsIcounter
   {-# INLINE rule1394 #-}
   rule1394 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1395 #-}
   rule1395 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _declarationsIdictionaryEnvironment
   {-# INLINE rule1396 #-}
   rule1396 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1397 #-}
   rule1397 = \ ((_declarationsImatchIO) :: IO ()) ->
     _declarationsImatchIO
   {-# INLINE rule1398 #-}
   rule1398 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1399 #-}
   rule1399 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule1400 #-}
   rule1400 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1401 #-}
   rule1401 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
     _declarationsIpatternMatchWarnings
   {-# INLINE rule1402 #-}
   rule1402 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1403 #-}
   rule1403 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1404 #-}
   rule1404 = \ ((_declarationsIuniqueChunk) :: Int) ->
     _declarationsIuniqueChunk
   {-# INLINE rule1405 #-}
   rule1405 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Do #-}
sem_Expression_Do :: T_Range  -> T_Statements  -> T_Expression 
sem_Expression_Do arg_range_ arg_statements_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _statementsX158 = Control.Monad.Identity.runIdentity (attach_T_Statements (arg_statements_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Statements_vOut157 _statementsIassumptions _statementsIbetaUnique _statementsIcollectErrors _statementsIcollectInstances _statementsIcollectWarnings _statementsIconstraints _statementsIcounter _statementsIdictionaryEnvironment _statementsIgeneratorBeta _statementsIinfoTrees _statementsImatchIO _statementsInamesInScope _statementsIpatternMatchWarnings _statementsIself _statementsIunboundNames _statementsIuniqueChunk _statementsIuniqueSecondRound) = inv_Statements_s158 _statementsX158 (T_Statements_vIn157 _statementsOallPatterns _statementsOallTypeSchemes _statementsOassumptions _statementsOavailablePredicates _statementsObetaUnique _statementsOclassEnvironment _statementsOcollectErrors _statementsOcollectWarnings _statementsOconstraints _statementsOcounter _statementsOcurrentChunk _statementsOdictionaryEnvironment _statementsOgeneratorBeta _statementsOimportEnvironment _statementsOmatchIO _statementsOmonos _statementsOnamesInScope _statementsOorderedTypeSynonyms _statementsOparentTree _statementsOpatternMatchWarnings _statementsOsubstitution _statementsOtypeschemeMap _statementsOunboundNames _statementsOuniqueChunk _statementsOuniqueSecondRound)
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1406 _newcon _statementsIconstraints
         _statementsObetaUnique = rule1407 _lhsIbetaUnique
         _statementsOgeneratorBeta = rule1408  ()
         _statementsOassumptions = rule1409  ()
         _assumptions = rule1410 _statementsIassumptions
         _constraints = rule1411  ()
         _beta = rule1412 _lhsIbetaUnique
         _newcon = rule1413 _beta _cinfo _statementsIgeneratorBeta
         _cinfo = rule1414 _parentTree
         _localInfo = rule1415 _beta _lhsImonos _self
         _parentTree = rule1416 _lhsIparentTree _localInfo _statementsIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1417 _parentTree
         _statementsOunboundNames = rule1418  ()
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1419 _assumptions _constraints _lhsItryPatterns _localInfo
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1420 _statementsIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1421 _statementsIunboundNames
         _self = rule1422 _rangeIself _statementsIself
         _lhsOself :: Expression
         _lhsOself = rule1423 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1424 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1425 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1426 _statementsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1427 _statementsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1428 _statementsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1429 _statementsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1430 _statementsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1431 _statementsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1432 _statementsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1433 _statementsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1434 _statementsIuniqueSecondRound
         _statementsOallPatterns = rule1435 _lhsIallPatterns
         _statementsOallTypeSchemes = rule1436 _lhsIallTypeSchemes
         _statementsOavailablePredicates = rule1437 _lhsIavailablePredicates
         _statementsOclassEnvironment = rule1438 _lhsIclassEnvironment
         _statementsOcollectErrors = rule1439 _lhsIcollectErrors
         _statementsOcollectWarnings = rule1440 _lhsIcollectWarnings
         _statementsOconstraints = rule1441 _constraints
         _statementsOcounter = rule1442 _lhsIcounter
         _statementsOcurrentChunk = rule1443 _lhsIcurrentChunk
         _statementsOdictionaryEnvironment = rule1444 _lhsIdictionaryEnvironment
         _statementsOimportEnvironment = rule1445 _lhsIimportEnvironment
         _statementsOmatchIO = rule1446 _lhsImatchIO
         _statementsOmonos = rule1447 _lhsImonos
         _statementsOnamesInScope = rule1448 _lhsInamesInScope
         _statementsOorderedTypeSynonyms = rule1449 _lhsIorderedTypeSynonyms
         _statementsOparentTree = rule1450 _parentTree
         _statementsOpatternMatchWarnings = rule1451 _lhsIpatternMatchWarnings
         _statementsOsubstitution = rule1452 _lhsIsubstitution
         _statementsOtypeschemeMap = rule1453 _lhsItypeschemeMap
         _statementsOuniqueChunk = rule1454 _lhsIuniqueChunk
         _statementsOuniqueSecondRound = rule1455 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1406 #-}
   rule1406 = \ _newcon ((_statementsIconstraints) :: ConstraintSet) ->
                                     Node [ _newcon .<. _statementsIconstraints ]
   {-# INLINE rule1407 #-}
   rule1407 = \ ((_lhsIbetaUnique) :: Int) ->
                                     _lhsIbetaUnique + 1
   {-# INLINE rule1408 #-}
   rule1408 = \  (_ :: ()) ->
                                     Nothing
   {-# INLINE rule1409 #-}
   rule1409 = \  (_ :: ()) ->
                                     noAssumptions
   {-# INLINE rule1410 #-}
   rule1410 = \ ((_statementsIassumptions) :: Assumptions) ->
                                     _statementsIassumptions
   {-# INLINE rule1411 #-}
   rule1411 = \  (_ :: ()) ->
                                     emptyTree
   {-# INLINE rule1412 #-}
   rule1412 = \ ((_lhsIbetaUnique) :: Int) ->
                                     TVar _lhsIbetaUnique
   {-# INLINE rule1413 #-}
   rule1413 = \ _beta _cinfo ((_statementsIgeneratorBeta) :: Maybe Tp) ->
                                     case _statementsIgeneratorBeta of
                                        Nothing -> []
                                        Just b  -> [ (ioType b .==. _beta) _cinfo ]
   {-# INLINE rule1414 #-}
   rule1414 = \ _parentTree ->
     resultConstraint "do-expression" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule1415 #-}
   rule1415 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1416 #-}
   rule1416 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_statementsIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo _statementsIinfoTrees
   {-# INLINE rule1417 #-}
   rule1417 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1418 #-}
   rule1418 = \  (_ :: ()) ->
                                      []
   {-# INLINE rule1419 #-}
   rule1419 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in matchOnlyVariable infoTuple _lhsItryPatterns
   {-# INLINE rule1420 #-}
   rule1420 = \ ((_statementsIcollectInstances) :: [(Name, Instance)]) ->
     _statementsIcollectInstances
   {-# INLINE rule1421 #-}
   rule1421 = \ ((_statementsIunboundNames) :: Names) ->
     _statementsIunboundNames
   {-# INLINE rule1422 #-}
   rule1422 = \ ((_rangeIself) :: Range) ((_statementsIself) :: Statements) ->
     Expression_Do _rangeIself _statementsIself
   {-# INLINE rule1423 #-}
   rule1423 = \ _self ->
     _self
   {-# INLINE rule1424 #-}
   rule1424 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1425 #-}
   rule1425 = \ _beta ->
     _beta
   {-# INLINE rule1426 #-}
   rule1426 = \ ((_statementsIbetaUnique) :: Int) ->
     _statementsIbetaUnique
   {-# INLINE rule1427 #-}
   rule1427 = \ ((_statementsIcollectErrors) :: TypeErrors) ->
     _statementsIcollectErrors
   {-# INLINE rule1428 #-}
   rule1428 = \ ((_statementsIcollectWarnings) :: Warnings) ->
     _statementsIcollectWarnings
   {-# INLINE rule1429 #-}
   rule1429 = \ ((_statementsIcounter) :: Int) ->
     _statementsIcounter
   {-# INLINE rule1430 #-}
   rule1430 = \ ((_statementsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _statementsIdictionaryEnvironment
   {-# INLINE rule1431 #-}
   rule1431 = \ ((_statementsImatchIO) :: IO ()) ->
     _statementsImatchIO
   {-# INLINE rule1432 #-}
   rule1432 = \ ((_statementsIpatternMatchWarnings) :: [Warning]) ->
     _statementsIpatternMatchWarnings
   {-# INLINE rule1433 #-}
   rule1433 = \ ((_statementsIuniqueChunk) :: Int) ->
     _statementsIuniqueChunk
   {-# INLINE rule1434 #-}
   rule1434 = \ ((_statementsIuniqueSecondRound) :: Int) ->
     _statementsIuniqueSecondRound
   {-# INLINE rule1435 #-}
   rule1435 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1436 #-}
   rule1436 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1437 #-}
   rule1437 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1438 #-}
   rule1438 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1439 #-}
   rule1439 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1440 #-}
   rule1440 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1441 #-}
   rule1441 = \ _constraints ->
     _constraints
   {-# INLINE rule1442 #-}
   rule1442 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1443 #-}
   rule1443 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1444 #-}
   rule1444 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1445 #-}
   rule1445 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1446 #-}
   rule1446 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1447 #-}
   rule1447 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1448 #-}
   rule1448 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1449 #-}
   rule1449 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1450 #-}
   rule1450 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1451 #-}
   rule1451 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1452 #-}
   rule1452 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1453 #-}
   rule1453 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1454 #-}
   rule1454 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1455 #-}
   rule1455 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_List #-}
sem_Expression_List :: T_Range  -> T_Expressions  -> T_Expression 
sem_Expression_List arg_range_ arg_expressions_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionsX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_expressions_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expressions_vOut43 _expressionsIassumptions _expressionsIbetaUnique _expressionsIbetas _expressionsIcollectErrors _expressionsIcollectInstances _expressionsIcollectWarnings _expressionsIconstraintslist _expressionsIcounter _expressionsIdictionaryEnvironment _expressionsIinfoTrees _expressionsImatchIO _expressionsImatches _expressionsIpatternMatchWarnings _expressionsIself _expressionsIunboundNames _expressionsIuniqueChunk _expressionsIuniqueSecondRound) = inv_Expressions_s44 _expressionsX44 (T_Expressions_vIn43 _expressionsOallPatterns _expressionsOallTypeSchemes _expressionsOavailablePredicates _expressionsObetaUnique _expressionsOclassEnvironment _expressionsOcollectErrors _expressionsOcollectWarnings _expressionsOcounter _expressionsOcurrentChunk _expressionsOdictionaryEnvironment _expressionsOimportEnvironment _expressionsOmatchIO _expressionsOmonos _expressionsOnamesInScope _expressionsOorderedTypeSynonyms _expressionsOparentTree _expressionsOpatternMatchWarnings _expressionsOsubstitution _expressionsOtryPatterns _expressionsOtypeschemeMap _expressionsOuniqueChunk _expressionsOuniqueSecondRound)
         _expressionsObetaUnique = rule1456 _lhsIbetaUnique
         _constraints = rule1457 _expressionsIbetas _expressionsIconstraintslist _newcon _zipf
         _beta = rule1458 _lhsIbetaUnique
         _beta' = rule1459 _lhsIbetaUnique
         _newcon = rule1460 _beta _beta' _cinfoResult
         _zipf = rule1461 _beta' _cinfoElem
         _cinfoElem = rule1462 _beta' _expressionsIbetas _localInfo _parentTree
         _cinfoResult = rule1463 _parentTree
         _localInfo = rule1464 _beta _lhsImonos _self
         _parentTree = rule1465 _expressionsIinfoTrees _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1466 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         (_expressionsOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1467 _constraints _expressionsIassumptions _expressionsImatches _expressionsIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1468 _expressionsImatchIO _ioMatch
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1469 _expressionsIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1470 _expressionsIunboundNames
         _self = rule1471 _expressionsIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1472 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1473 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1474 _expressionsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1475 _expressionsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1476 _expressionsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1477 _expressionsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1478 _expressionsIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1479 _expressionsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1480 _expressionsIuniqueChunk
         _expressionsOallPatterns = rule1481 _lhsIallPatterns
         _expressionsOallTypeSchemes = rule1482 _lhsIallTypeSchemes
         _expressionsOavailablePredicates = rule1483 _lhsIavailablePredicates
         _expressionsOclassEnvironment = rule1484 _lhsIclassEnvironment
         _expressionsOcollectErrors = rule1485 _lhsIcollectErrors
         _expressionsOcollectWarnings = rule1486 _lhsIcollectWarnings
         _expressionsOcounter = rule1487 _lhsIcounter
         _expressionsOcurrentChunk = rule1488 _lhsIcurrentChunk
         _expressionsOdictionaryEnvironment = rule1489 _lhsIdictionaryEnvironment
         _expressionsOimportEnvironment = rule1490 _lhsIimportEnvironment
         _expressionsOmatchIO = rule1491 _lhsImatchIO
         _expressionsOmonos = rule1492 _lhsImonos
         _expressionsOnamesInScope = rule1493 _lhsInamesInScope
         _expressionsOorderedTypeSynonyms = rule1494 _lhsIorderedTypeSynonyms
         _expressionsOparentTree = rule1495 _parentTree
         _expressionsOpatternMatchWarnings = rule1496 _lhsIpatternMatchWarnings
         _expressionsOsubstitution = rule1497 _lhsIsubstitution
         _expressionsOtypeschemeMap = rule1498 _lhsItypeschemeMap
         _expressionsOuniqueChunk = rule1499 _lhsIuniqueChunk
         _expressionsOuniqueSecondRound = rule1500 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1456 #-}
   rule1456 = \ ((_lhsIbetaUnique) :: Int) ->
                                     _lhsIbetaUnique + 2
   {-# INLINE rule1457 #-}
   rule1457 = \ ((_expressionsIbetas) :: Tps) ((_expressionsIconstraintslist) :: ConstraintSets) _newcon _zipf ->
                                     _newcon .>.
                                      Node (zipWith3 _zipf _expressionsIbetas [0..] _expressionsIconstraintslist)
   {-# INLINE rule1458 #-}
   rule1458 = \ ((_lhsIbetaUnique) :: Int) ->
                                     TVar _lhsIbetaUnique
   {-# INLINE rule1459 #-}
   rule1459 = \ ((_lhsIbetaUnique) :: Int) ->
                                     TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule1460 #-}
   rule1460 = \ _beta _beta' _cinfoResult ->
                                     [ (listType _beta' .==. _beta) _cinfoResult ]
   {-# INLINE rule1461 #-}
   rule1461 = \ _beta' _cinfoElem ->
                                     \tp childNr ctree -> [ (tp .==. _beta') (_cinfoElem childNr) ] .<. ctree
   {-# INLINE rule1462 #-}
   rule1462 = \ _beta' ((_expressionsIbetas) :: Tps) _localInfo _parentTree ->
     \elemNr ->
     childConstraint elemNr "element of list" _parentTree $
        [ HasTrustFactor 10.0 | length _expressionsIbetas < 2 ] ++
        [ Unifier (head (ftv _beta')) ("list", _localInfo, ordinal False (elemNr+1) ++ " element") ]
   {-# INLINE rule1463 #-}
   rule1463 = \ _parentTree ->
     resultConstraint "list" _parentTree
     [ FolkloreConstraint ]
   {-# INLINE rule1464 #-}
   rule1464 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1465 #-}
   rule1465 = \ ((_expressionsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo (_expressionsIinfoTrees)
   {-# INLINE rule1466 #-}
   rule1466 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1467 #-}
   rule1467 = \ _constraints ((_expressionsIassumptions) :: Assumptions) ((_expressionsImatches) :: [Maybe MetaVariableTable]) ((_expressionsIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _expressionsIassumptions _localInfo
            in match1 infoTuple _expressionsIuniqueSecondRound
                      match_Expression_List
                      _lhsItryPatterns _lhsIallPatterns
                      [_expressionsImatches]
   {-# INLINE rule1468 #-}
   rule1468 = \ ((_expressionsImatchIO) :: IO ()) _ioMatch ->
                                       _expressionsImatchIO     >> _ioMatch
   {-# INLINE rule1469 #-}
   rule1469 = \ ((_expressionsIcollectInstances) :: [(Name, Instance)]) ->
     _expressionsIcollectInstances
   {-# INLINE rule1470 #-}
   rule1470 = \ ((_expressionsIunboundNames) :: Names) ->
     _expressionsIunboundNames
   {-# INLINE rule1471 #-}
   rule1471 = \ ((_expressionsIself) :: Expressions) ((_rangeIself) :: Range) ->
     Expression_List _rangeIself _expressionsIself
   {-# INLINE rule1472 #-}
   rule1472 = \ _self ->
     _self
   {-# INLINE rule1473 #-}
   rule1473 = \ _beta ->
     _beta
   {-# INLINE rule1474 #-}
   rule1474 = \ ((_expressionsIbetaUnique) :: Int) ->
     _expressionsIbetaUnique
   {-# INLINE rule1475 #-}
   rule1475 = \ ((_expressionsIcollectErrors) :: TypeErrors) ->
     _expressionsIcollectErrors
   {-# INLINE rule1476 #-}
   rule1476 = \ ((_expressionsIcollectWarnings) :: Warnings) ->
     _expressionsIcollectWarnings
   {-# INLINE rule1477 #-}
   rule1477 = \ ((_expressionsIcounter) :: Int) ->
     _expressionsIcounter
   {-# INLINE rule1478 #-}
   rule1478 = \ ((_expressionsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionsIdictionaryEnvironment
   {-# INLINE rule1479 #-}
   rule1479 = \ ((_expressionsIpatternMatchWarnings) :: [Warning]) ->
     _expressionsIpatternMatchWarnings
   {-# INLINE rule1480 #-}
   rule1480 = \ ((_expressionsIuniqueChunk) :: Int) ->
     _expressionsIuniqueChunk
   {-# INLINE rule1481 #-}
   rule1481 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1482 #-}
   rule1482 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1483 #-}
   rule1483 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1484 #-}
   rule1484 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1485 #-}
   rule1485 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1486 #-}
   rule1486 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1487 #-}
   rule1487 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1488 #-}
   rule1488 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1489 #-}
   rule1489 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1490 #-}
   rule1490 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1491 #-}
   rule1491 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1492 #-}
   rule1492 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1493 #-}
   rule1493 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1494 #-}
   rule1494 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1495 #-}
   rule1495 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1496 #-}
   rule1496 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1497 #-}
   rule1497 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1498 #-}
   rule1498 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1499 #-}
   rule1499 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1500 #-}
   rule1500 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Tuple #-}
sem_Expression_Tuple :: T_Range  -> T_Expressions  -> T_Expression 
sem_Expression_Tuple arg_range_ arg_expressions_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionsX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_expressions_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expressions_vOut43 _expressionsIassumptions _expressionsIbetaUnique _expressionsIbetas _expressionsIcollectErrors _expressionsIcollectInstances _expressionsIcollectWarnings _expressionsIconstraintslist _expressionsIcounter _expressionsIdictionaryEnvironment _expressionsIinfoTrees _expressionsImatchIO _expressionsImatches _expressionsIpatternMatchWarnings _expressionsIself _expressionsIunboundNames _expressionsIuniqueChunk _expressionsIuniqueSecondRound) = inv_Expressions_s44 _expressionsX44 (T_Expressions_vIn43 _expressionsOallPatterns _expressionsOallTypeSchemes _expressionsOavailablePredicates _expressionsObetaUnique _expressionsOclassEnvironment _expressionsOcollectErrors _expressionsOcollectWarnings _expressionsOcounter _expressionsOcurrentChunk _expressionsOdictionaryEnvironment _expressionsOimportEnvironment _expressionsOmatchIO _expressionsOmonos _expressionsOnamesInScope _expressionsOorderedTypeSynonyms _expressionsOparentTree _expressionsOpatternMatchWarnings _expressionsOsubstitution _expressionsOtryPatterns _expressionsOtypeschemeMap _expressionsOuniqueChunk _expressionsOuniqueSecondRound)
         _expressionsObetaUnique = rule1501 _lhsIbetaUnique
         _constraints = rule1502 _expressionsIconstraintslist _newcon
         _beta = rule1503 _lhsIbetaUnique
         _newcon = rule1504 _beta _cinfo _expressionsIbetas
         _cinfo = rule1505 _parentTree
         _localInfo = rule1506 _beta _lhsImonos _self
         _parentTree = rule1507 _expressionsIinfoTrees _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1508 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         (_expressionsOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1509 _constraints _expressionsIassumptions _expressionsImatches _expressionsIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1510 _expressionsImatchIO _ioMatch
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1511 _expressionsIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1512 _expressionsIunboundNames
         _self = rule1513 _expressionsIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1514 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1515 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1516 _expressionsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1517 _expressionsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1518 _expressionsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1519 _expressionsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1520 _expressionsIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1521 _expressionsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1522 _expressionsIuniqueChunk
         _expressionsOallPatterns = rule1523 _lhsIallPatterns
         _expressionsOallTypeSchemes = rule1524 _lhsIallTypeSchemes
         _expressionsOavailablePredicates = rule1525 _lhsIavailablePredicates
         _expressionsOclassEnvironment = rule1526 _lhsIclassEnvironment
         _expressionsOcollectErrors = rule1527 _lhsIcollectErrors
         _expressionsOcollectWarnings = rule1528 _lhsIcollectWarnings
         _expressionsOcounter = rule1529 _lhsIcounter
         _expressionsOcurrentChunk = rule1530 _lhsIcurrentChunk
         _expressionsOdictionaryEnvironment = rule1531 _lhsIdictionaryEnvironment
         _expressionsOimportEnvironment = rule1532 _lhsIimportEnvironment
         _expressionsOmatchIO = rule1533 _lhsImatchIO
         _expressionsOmonos = rule1534 _lhsImonos
         _expressionsOnamesInScope = rule1535 _lhsInamesInScope
         _expressionsOorderedTypeSynonyms = rule1536 _lhsIorderedTypeSynonyms
         _expressionsOparentTree = rule1537 _parentTree
         _expressionsOpatternMatchWarnings = rule1538 _lhsIpatternMatchWarnings
         _expressionsOsubstitution = rule1539 _lhsIsubstitution
         _expressionsOtypeschemeMap = rule1540 _lhsItypeschemeMap
         _expressionsOuniqueChunk = rule1541 _lhsIuniqueChunk
         _expressionsOuniqueSecondRound = rule1542 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1501 #-}
   rule1501 = \ ((_lhsIbetaUnique) :: Int) ->
                                    _lhsIbetaUnique + 1
   {-# INLINE rule1502 #-}
   rule1502 = \ ((_expressionsIconstraintslist) :: ConstraintSets) _newcon ->
                                    _newcon .>. Node _expressionsIconstraintslist
   {-# INLINE rule1503 #-}
   rule1503 = \ ((_lhsIbetaUnique) :: Int) ->
                                    TVar _lhsIbetaUnique
   {-# INLINE rule1504 #-}
   rule1504 = \ _beta _cinfo ((_expressionsIbetas) :: Tps) ->
                                    [ (tupleType _expressionsIbetas .==. _beta) _cinfo ]
   {-# INLINE rule1505 #-}
   rule1505 = \ _parentTree ->
     resultConstraint "tuple" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule1506 #-}
   rule1506 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1507 #-}
   rule1507 = \ ((_expressionsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo (_expressionsIinfoTrees)
   {-# INLINE rule1508 #-}
   rule1508 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1509 #-}
   rule1509 = \ _constraints ((_expressionsIassumptions) :: Assumptions) ((_expressionsImatches) :: [Maybe MetaVariableTable]) ((_expressionsIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _expressionsIassumptions _localInfo
            in match1 infoTuple _expressionsIuniqueSecondRound
                      match_Expression_Tuple
                      _lhsItryPatterns _lhsIallPatterns
                      [_expressionsImatches]
   {-# INLINE rule1510 #-}
   rule1510 = \ ((_expressionsImatchIO) :: IO ()) _ioMatch ->
                                       _expressionsImatchIO     >> _ioMatch
   {-# INLINE rule1511 #-}
   rule1511 = \ ((_expressionsIcollectInstances) :: [(Name, Instance)]) ->
     _expressionsIcollectInstances
   {-# INLINE rule1512 #-}
   rule1512 = \ ((_expressionsIunboundNames) :: Names) ->
     _expressionsIunboundNames
   {-# INLINE rule1513 #-}
   rule1513 = \ ((_expressionsIself) :: Expressions) ((_rangeIself) :: Range) ->
     Expression_Tuple _rangeIself _expressionsIself
   {-# INLINE rule1514 #-}
   rule1514 = \ _self ->
     _self
   {-# INLINE rule1515 #-}
   rule1515 = \ _beta ->
     _beta
   {-# INLINE rule1516 #-}
   rule1516 = \ ((_expressionsIbetaUnique) :: Int) ->
     _expressionsIbetaUnique
   {-# INLINE rule1517 #-}
   rule1517 = \ ((_expressionsIcollectErrors) :: TypeErrors) ->
     _expressionsIcollectErrors
   {-# INLINE rule1518 #-}
   rule1518 = \ ((_expressionsIcollectWarnings) :: Warnings) ->
     _expressionsIcollectWarnings
   {-# INLINE rule1519 #-}
   rule1519 = \ ((_expressionsIcounter) :: Int) ->
     _expressionsIcounter
   {-# INLINE rule1520 #-}
   rule1520 = \ ((_expressionsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionsIdictionaryEnvironment
   {-# INLINE rule1521 #-}
   rule1521 = \ ((_expressionsIpatternMatchWarnings) :: [Warning]) ->
     _expressionsIpatternMatchWarnings
   {-# INLINE rule1522 #-}
   rule1522 = \ ((_expressionsIuniqueChunk) :: Int) ->
     _expressionsIuniqueChunk
   {-# INLINE rule1523 #-}
   rule1523 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1524 #-}
   rule1524 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1525 #-}
   rule1525 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1526 #-}
   rule1526 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1527 #-}
   rule1527 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1528 #-}
   rule1528 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1529 #-}
   rule1529 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1530 #-}
   rule1530 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1531 #-}
   rule1531 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1532 #-}
   rule1532 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1533 #-}
   rule1533 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1534 #-}
   rule1534 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1535 #-}
   rule1535 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1536 #-}
   rule1536 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1537 #-}
   rule1537 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1538 #-}
   rule1538 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1539 #-}
   rule1539 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1540 #-}
   rule1540 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1541 #-}
   rule1541 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1542 #-}
   rule1542 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_Comprehension #-}
sem_Expression_Comprehension :: T_Range  -> T_Expression  -> T_Qualifiers  -> T_Expression 
sem_Expression_Comprehension arg_range_ arg_expression_ arg_qualifiers_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         _qualifiersX131 = Control.Monad.Identity.runIdentity (attach_T_Qualifiers (arg_qualifiers_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         (T_Qualifiers_vOut130 _qualifiersIassumptions _qualifiersIbetaUnique _qualifiersIcollectErrors _qualifiersIcollectInstances _qualifiersIcollectWarnings _qualifiersIconstraints _qualifiersIcounter _qualifiersIdictionaryEnvironment _qualifiersIinfoTrees _qualifiersImatchIO _qualifiersImonos _qualifiersInamesInScope _qualifiersIpatternMatchWarnings _qualifiersIself _qualifiersIunboundNames _qualifiersIuniqueChunk _qualifiersIuniqueSecondRound) = inv_Qualifiers_s131 _qualifiersX131 (T_Qualifiers_vIn130 _qualifiersOallPatterns _qualifiersOallTypeSchemes _qualifiersOassumptions _qualifiersOavailablePredicates _qualifiersObetaUnique _qualifiersOclassEnvironment _qualifiersOcollectErrors _qualifiersOcollectWarnings _qualifiersOconstraints _qualifiersOcounter _qualifiersOcurrentChunk _qualifiersOdictionaryEnvironment _qualifiersOimportEnvironment _qualifiersOmatchIO _qualifiersOmonos _qualifiersOnamesInScope _qualifiersOorderedTypeSynonyms _qualifiersOparentTree _qualifiersOpatternMatchWarnings _qualifiersOsubstitution _qualifiersOtypeschemeMap _qualifiersOunboundNames _qualifiersOuniqueChunk _qualifiersOuniqueSecondRound)
         _expressionObetaUnique = rule1543 _lhsIbetaUnique
         _expressionOmonos = rule1544 _qualifiersImonos
         _qualifiersOassumptions = rule1545 _expressionIassumptions
         _qualifiersOconstraints = rule1546 _expressionIconstraints
         _qualifiersOmonos = rule1547 _lhsImonos
         _assumptions = rule1548 _qualifiersIassumptions
         _constraints = rule1549 _newcon _qualifiersIconstraints
         _beta = rule1550 _lhsIbetaUnique
         _newcon = rule1551 _beta _cinfo _expressionIbeta
         _cinfo = rule1552 _parentTree
         _localInfo = rule1553 _beta _lhsImonos _self
         _parentTree = rule1554 _lhsIparentTree _localInfo _qualifiersIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1555 _parentTree
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1556 _qualifiersIunboundNames
         _expressionOnamesInScope = rule1557 _qualifiersInamesInScope
         _qualifiersOnamesInScope = rule1558 _lhsInamesInScope
         _qualifiersOunboundNames = rule1559 _expressionIunboundNames
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1560 _assumptions _constraints _lhsItryPatterns _localInfo
         _expressionOtryPatterns = rule1561  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1562 _expressionIcollectInstances _qualifiersIcollectInstances
         _self = rule1563 _expressionIself _qualifiersIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1564 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1565 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1566 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1567 _qualifiersIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1568 _qualifiersIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1569 _qualifiersIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1570 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1571 _qualifiersIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1572 _qualifiersIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1573 _qualifiersImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1574 _qualifiersIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1575 _qualifiersIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1576 _qualifiersIuniqueSecondRound
         _expressionOallPatterns = rule1577 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1578 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1579 _lhsIavailablePredicates
         _expressionOclassEnvironment = rule1580 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1581 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1582 _lhsIcollectWarnings
         _expressionOcounter = rule1583 _lhsIcounter
         _expressionOcurrentChunk = rule1584 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1585 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1586 _lhsIimportEnvironment
         _expressionOmatchIO = rule1587 _lhsImatchIO
         _expressionOorderedTypeSynonyms = rule1588 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1589 _parentTree
         _expressionOpatternMatchWarnings = rule1590 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule1591 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1592 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1593 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1594 _lhsIuniqueSecondRound
         _qualifiersOallPatterns = rule1595 _lhsIallPatterns
         _qualifiersOallTypeSchemes = rule1596 _lhsIallTypeSchemes
         _qualifiersOavailablePredicates = rule1597 _lhsIavailablePredicates
         _qualifiersObetaUnique = rule1598 _expressionIbetaUnique
         _qualifiersOclassEnvironment = rule1599 _lhsIclassEnvironment
         _qualifiersOcollectErrors = rule1600 _expressionIcollectErrors
         _qualifiersOcollectWarnings = rule1601 _expressionIcollectWarnings
         _qualifiersOcounter = rule1602 _expressionIcounter
         _qualifiersOcurrentChunk = rule1603 _lhsIcurrentChunk
         _qualifiersOdictionaryEnvironment = rule1604 _expressionIdictionaryEnvironment
         _qualifiersOimportEnvironment = rule1605 _lhsIimportEnvironment
         _qualifiersOmatchIO = rule1606 _expressionImatchIO
         _qualifiersOorderedTypeSynonyms = rule1607 _lhsIorderedTypeSynonyms
         _qualifiersOparentTree = rule1608 _parentTree
         _qualifiersOpatternMatchWarnings = rule1609 _expressionIpatternMatchWarnings
         _qualifiersOsubstitution = rule1610 _lhsIsubstitution
         _qualifiersOtypeschemeMap = rule1611 _lhsItypeschemeMap
         _qualifiersOuniqueChunk = rule1612 _expressionIuniqueChunk
         _qualifiersOuniqueSecondRound = rule1613 _expressionIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1543 #-}
   rule1543 = \ ((_lhsIbetaUnique) :: Int) ->
                                   _lhsIbetaUnique + 1
   {-# INLINE rule1544 #-}
   rule1544 = \ ((_qualifiersImonos) :: Monos) ->
                                   _qualifiersImonos
   {-# INLINE rule1545 #-}
   rule1545 = \ ((_expressionIassumptions) :: Assumptions) ->
                                   _expressionIassumptions
   {-# INLINE rule1546 #-}
   rule1546 = \ ((_expressionIconstraints) :: ConstraintSet) ->
                                   _expressionIconstraints
   {-# INLINE rule1547 #-}
   rule1547 = \ ((_lhsImonos) :: Monos) ->
                                   _lhsImonos
   {-# INLINE rule1548 #-}
   rule1548 = \ ((_qualifiersIassumptions) :: Assumptions) ->
                                   _qualifiersIassumptions
   {-# INLINE rule1549 #-}
   rule1549 = \ _newcon ((_qualifiersIconstraints) :: ConstraintSet) ->
                                   _newcon .>. Node [ _qualifiersIconstraints ]
   {-# INLINE rule1550 #-}
   rule1550 = \ ((_lhsIbetaUnique) :: Int) ->
                                   TVar _lhsIbetaUnique
   {-# INLINE rule1551 #-}
   rule1551 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ->
                                   [ (listType _expressionIbeta .==. _beta) _cinfo ]
   {-# INLINE rule1552 #-}
   rule1552 = \ _parentTree ->
     resultConstraint "list comprehension" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule1553 #-}
   rule1553 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1554 #-}
   rule1554 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_qualifiersIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo _qualifiersIinfoTrees
   {-# INLINE rule1555 #-}
   rule1555 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1556 #-}
   rule1556 = \ ((_qualifiersIunboundNames) :: Names) ->
                                                   _qualifiersIunboundNames
   {-# INLINE rule1557 #-}
   rule1557 = \ ((_qualifiersInamesInScope) :: Names) ->
                                                   _qualifiersInamesInScope
   {-# INLINE rule1558 #-}
   rule1558 = \ ((_lhsInamesInScope) :: Names) ->
                                                   _lhsInamesInScope
   {-# INLINE rule1559 #-}
   rule1559 = \ ((_expressionIunboundNames) :: Names) ->
                                                   _expressionIunboundNames
   {-# INLINE rule1560 #-}
   rule1560 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in matchOnlyVariable infoTuple _lhsItryPatterns
   {-# INLINE rule1561 #-}
   rule1561 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule1562 #-}
   rule1562 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_qualifiersIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances  ++  _qualifiersIcollectInstances
   {-# INLINE rule1563 #-}
   rule1563 = \ ((_expressionIself) :: Expression) ((_qualifiersIself) :: Qualifiers) ((_rangeIself) :: Range) ->
     Expression_Comprehension _rangeIself _expressionIself _qualifiersIself
   {-# INLINE rule1564 #-}
   rule1564 = \ _self ->
     _self
   {-# INLINE rule1565 #-}
   rule1565 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1566 #-}
   rule1566 = \ _beta ->
     _beta
   {-# INLINE rule1567 #-}
   rule1567 = \ ((_qualifiersIbetaUnique) :: Int) ->
     _qualifiersIbetaUnique
   {-# INLINE rule1568 #-}
   rule1568 = \ ((_qualifiersIcollectErrors) :: TypeErrors) ->
     _qualifiersIcollectErrors
   {-# INLINE rule1569 #-}
   rule1569 = \ ((_qualifiersIcollectWarnings) :: Warnings) ->
     _qualifiersIcollectWarnings
   {-# INLINE rule1570 #-}
   rule1570 = \ _constraints ->
     _constraints
   {-# INLINE rule1571 #-}
   rule1571 = \ ((_qualifiersIcounter) :: Int) ->
     _qualifiersIcounter
   {-# INLINE rule1572 #-}
   rule1572 = \ ((_qualifiersIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _qualifiersIdictionaryEnvironment
   {-# INLINE rule1573 #-}
   rule1573 = \ ((_qualifiersImatchIO) :: IO ()) ->
     _qualifiersImatchIO
   {-# INLINE rule1574 #-}
   rule1574 = \ ((_qualifiersIpatternMatchWarnings) :: [Warning]) ->
     _qualifiersIpatternMatchWarnings
   {-# INLINE rule1575 #-}
   rule1575 = \ ((_qualifiersIuniqueChunk) :: Int) ->
     _qualifiersIuniqueChunk
   {-# INLINE rule1576 #-}
   rule1576 = \ ((_qualifiersIuniqueSecondRound) :: Int) ->
     _qualifiersIuniqueSecondRound
   {-# INLINE rule1577 #-}
   rule1577 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1578 #-}
   rule1578 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1579 #-}
   rule1579 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1580 #-}
   rule1580 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1581 #-}
   rule1581 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1582 #-}
   rule1582 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1583 #-}
   rule1583 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1584 #-}
   rule1584 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1585 #-}
   rule1585 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1586 #-}
   rule1586 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1587 #-}
   rule1587 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1588 #-}
   rule1588 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1589 #-}
   rule1589 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1590 #-}
   rule1590 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1591 #-}
   rule1591 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1592 #-}
   rule1592 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1593 #-}
   rule1593 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1594 #-}
   rule1594 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1595 #-}
   rule1595 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1596 #-}
   rule1596 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1597 #-}
   rule1597 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1598 #-}
   rule1598 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1599 #-}
   rule1599 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1600 #-}
   rule1600 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1601 #-}
   rule1601 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1602 #-}
   rule1602 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1603 #-}
   rule1603 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1604 #-}
   rule1604 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1605 #-}
   rule1605 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1606 #-}
   rule1606 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule1607 #-}
   rule1607 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1608 #-}
   rule1608 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1609 #-}
   rule1609 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1610 #-}
   rule1610 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1611 #-}
   rule1611 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1612 #-}
   rule1612 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule1613 #-}
   rule1613 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
{-# NOINLINE sem_Expression_Typed #-}
sem_Expression_Typed :: T_Range  -> T_Expression  -> T_Type  -> T_Expression 
sem_Expression_Typed arg_range_ arg_expression_ arg_type_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _expressionObetaUnique = rule1614 _lhsIbetaUnique
         _assumptions = rule1615 _expressionIassumptions
         _constraints = rule1616 _conExpr _conResult _expressionIconstraints
         _beta = rule1617 _lhsIbetaUnique
         _typeScheme = rule1618 _typeIself
         _conResult = rule1619 _beta _cinfoResult _typeScheme
         _conExpr = rule1620 _cinfoExpr _expressionIbeta _lhsImonos _typeScheme
         _cinfoExpr = rule1621 _parentTree _typeIself
         _cinfoResult = rule1622 _parentTree
         _localInfo = rule1623 _beta _lhsImonos _self
         _parentTree = rule1624 _expressionIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1625 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1626 _assumptions _constraints _lhsItryPatterns _localInfo
         _expressionOtryPatterns = rule1627  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1628 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1629 _expressionIunboundNames
         _self = rule1630 _expressionIself _rangeIself _typeIself
         _lhsOself :: Expression
         _lhsOself = rule1631 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1632 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1633 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1634 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1635 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1636 _expressionIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1637 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1638 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1639 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1640 _expressionImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1641 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1642 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1643 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule1644 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1645 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1646 _lhsIavailablePredicates
         _expressionOclassEnvironment = rule1647 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1648 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1649 _lhsIcollectWarnings
         _expressionOcounter = rule1650 _lhsIcounter
         _expressionOcurrentChunk = rule1651 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1652 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1653 _lhsIimportEnvironment
         _expressionOmatchIO = rule1654 _lhsImatchIO
         _expressionOmonos = rule1655 _lhsImonos
         _expressionOnamesInScope = rule1656 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule1657 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1658 _parentTree
         _expressionOpatternMatchWarnings = rule1659 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule1660 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1661 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1662 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1663 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1614 #-}
   rule1614 = \ ((_lhsIbetaUnique) :: Int) ->
                                   _lhsIbetaUnique + 1
   {-# INLINE rule1615 #-}
   rule1615 = \ ((_expressionIassumptions) :: Assumptions) ->
                                   _expressionIassumptions
   {-# INLINE rule1616 #-}
   rule1616 = \ _conExpr _conResult ((_expressionIconstraints) :: ConstraintSet) ->
                                   _conResult .>.
                                   Node [ _conExpr .<. _expressionIconstraints ]
   {-# INLINE rule1617 #-}
   rule1617 = \ ((_lhsIbetaUnique) :: Int) ->
                                   TVar _lhsIbetaUnique
   {-# INLINE rule1618 #-}
   rule1618 = \ ((_typeIself) :: Type) ->
                                   makeTpSchemeFromType _typeIself
   {-# INLINE rule1619 #-}
   rule1619 = \ _beta _cinfoResult _typeScheme ->
                                   [ (_beta            .::. _typeScheme) _cinfoResult          ]
   {-# INLINE rule1620 #-}
   rule1620 = \ _cinfoExpr ((_expressionIbeta) :: Tp) ((_lhsImonos) :: Monos) _typeScheme ->
                                   [ (_expressionIbeta !::! _typeScheme) _lhsImonos _cinfoExpr ]
   {-# INLINE rule1621 #-}
   rule1621 = \ _parentTree ((_typeIself) :: Type) ->
     childConstraint 0 "type annotation" _parentTree
        [ TypeSignatureLocation (getTypeRange _typeIself) ]
   {-# INLINE rule1622 #-}
   rule1622 = \ _parentTree ->
     resultConstraint "type annotation" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule1623 #-}
   rule1623 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1624 #-}
   rule1624 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_expressionIinfoTree]
   {-# INLINE rule1625 #-}
   rule1625 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1626 #-}
   rule1626 = \ _assumptions _constraints ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _assumptions _localInfo
            in matchOnlyVariable infoTuple _lhsItryPatterns
   {-# INLINE rule1627 #-}
   rule1627 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule1628 #-}
   rule1628 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule1629 #-}
   rule1629 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule1630 #-}
   rule1630 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
     Expression_Typed _rangeIself _expressionIself _typeIself
   {-# INLINE rule1631 #-}
   rule1631 = \ _self ->
     _self
   {-# INLINE rule1632 #-}
   rule1632 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1633 #-}
   rule1633 = \ _beta ->
     _beta
   {-# INLINE rule1634 #-}
   rule1634 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1635 #-}
   rule1635 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1636 #-}
   rule1636 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1637 #-}
   rule1637 = \ _constraints ->
     _constraints
   {-# INLINE rule1638 #-}
   rule1638 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1639 #-}
   rule1639 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1640 #-}
   rule1640 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule1641 #-}
   rule1641 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1642 #-}
   rule1642 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule1643 #-}
   rule1643 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule1644 #-}
   rule1644 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1645 #-}
   rule1645 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1646 #-}
   rule1646 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1647 #-}
   rule1647 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1648 #-}
   rule1648 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1649 #-}
   rule1649 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1650 #-}
   rule1650 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1651 #-}
   rule1651 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1652 #-}
   rule1652 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1653 #-}
   rule1653 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1654 #-}
   rule1654 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1655 #-}
   rule1655 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1656 #-}
   rule1656 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1657 #-}
   rule1657 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1658 #-}
   rule1658 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1659 #-}
   rule1659 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1660 #-}
   rule1660 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1661 #-}
   rule1661 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1662 #-}
   rule1662 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1663 #-}
   rule1663 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_RecordConstruction #-}
sem_Expression_RecordConstruction :: T_Range  -> T_Name  -> T_RecordExpressionBindings  -> T_Expression 
sem_Expression_RecordConstruction arg_range_ arg_name_ arg_recordExpressionBindings_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _recordExpressionBindingsX140 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBindings (arg_recordExpressionBindings_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_RecordExpressionBindings_vOut139 _recordExpressionBindingsIcollectErrors _recordExpressionBindingsIcollectInstances _recordExpressionBindingsIcollectWarnings _recordExpressionBindingsIcounter _recordExpressionBindingsIdictionaryEnvironment _recordExpressionBindingsIpatternMatchWarnings _recordExpressionBindingsIself _recordExpressionBindingsIunboundNames _recordExpressionBindingsIuniqueChunk) = inv_RecordExpressionBindings_s140 _recordExpressionBindingsX140 (T_RecordExpressionBindings_vIn139 _recordExpressionBindingsOallTypeSchemes _recordExpressionBindingsOavailablePredicates _recordExpressionBindingsOclassEnvironment _recordExpressionBindingsOcollectErrors _recordExpressionBindingsOcollectWarnings _recordExpressionBindingsOcounter _recordExpressionBindingsOcurrentChunk _recordExpressionBindingsOdictionaryEnvironment _recordExpressionBindingsOimportEnvironment _recordExpressionBindingsOnamesInScope _recordExpressionBindingsOorderedTypeSynonyms _recordExpressionBindingsOpatternMatchWarnings _recordExpressionBindingsOsubstitution _recordExpressionBindingsOtypeschemeMap _recordExpressionBindingsOuniqueChunk)
         _infoTree = rule1664  ()
         (_assumptions,_constraints,_beta) = rule1665  ()
         _matches = rule1666  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1667 _recordExpressionBindingsIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1668 _recordExpressionBindingsIunboundNames
         _self = rule1669 _nameIself _rangeIself _recordExpressionBindingsIself
         _lhsOself :: Expression
         _lhsOself = rule1670 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1671 _assumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1672 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1673 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1674 _recordExpressionBindingsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1675 _recordExpressionBindingsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1676 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1677 _recordExpressionBindingsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1678 _recordExpressionBindingsIdictionaryEnvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1679 _infoTree
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1680 _lhsImatchIO
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1681 _matches
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1682 _recordExpressionBindingsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1683 _recordExpressionBindingsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1684 _lhsIuniqueSecondRound
         _recordExpressionBindingsOallTypeSchemes = rule1685 _lhsIallTypeSchemes
         _recordExpressionBindingsOavailablePredicates = rule1686 _lhsIavailablePredicates
         _recordExpressionBindingsOclassEnvironment = rule1687 _lhsIclassEnvironment
         _recordExpressionBindingsOcollectErrors = rule1688 _lhsIcollectErrors
         _recordExpressionBindingsOcollectWarnings = rule1689 _lhsIcollectWarnings
         _recordExpressionBindingsOcounter = rule1690 _lhsIcounter
         _recordExpressionBindingsOcurrentChunk = rule1691 _lhsIcurrentChunk
         _recordExpressionBindingsOdictionaryEnvironment = rule1692 _lhsIdictionaryEnvironment
         _recordExpressionBindingsOimportEnvironment = rule1693 _lhsIimportEnvironment
         _recordExpressionBindingsOnamesInScope = rule1694 _lhsInamesInScope
         _recordExpressionBindingsOorderedTypeSynonyms = rule1695 _lhsIorderedTypeSynonyms
         _recordExpressionBindingsOpatternMatchWarnings = rule1696 _lhsIpatternMatchWarnings
         _recordExpressionBindingsOsubstitution = rule1697 _lhsIsubstitution
         _recordExpressionBindingsOtypeschemeMap = rule1698 _lhsItypeschemeMap
         _recordExpressionBindingsOuniqueChunk = rule1699 _lhsIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1664 #-}
   rule1664 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule1665 #-}
   rule1665 = \  (_ :: ()) ->
                                                                 internalError "PartialSyntax.ag" "n/a" "Expression.RecordConstruction"
   {-# INLINE rule1666 #-}
   rule1666 = \  (_ :: ()) ->
                         internalError "TS_PatternMatching.ag" "n/a" "RecordConstruction is not supported"
   {-# INLINE rule1667 #-}
   rule1667 = \ ((_recordExpressionBindingsIcollectInstances) :: [(Name, Instance)]) ->
     _recordExpressionBindingsIcollectInstances
   {-# INLINE rule1668 #-}
   rule1668 = \ ((_recordExpressionBindingsIunboundNames) :: Names) ->
     _recordExpressionBindingsIunboundNames
   {-# INLINE rule1669 #-}
   rule1669 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_recordExpressionBindingsIself) :: RecordExpressionBindings) ->
     Expression_RecordConstruction _rangeIself _nameIself _recordExpressionBindingsIself
   {-# INLINE rule1670 #-}
   rule1670 = \ _self ->
     _self
   {-# INLINE rule1671 #-}
   rule1671 = \ _assumptions ->
     _assumptions
   {-# INLINE rule1672 #-}
   rule1672 = \ _beta ->
     _beta
   {-# INLINE rule1673 #-}
   rule1673 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule1674 #-}
   rule1674 = \ ((_recordExpressionBindingsIcollectErrors) :: TypeErrors) ->
     _recordExpressionBindingsIcollectErrors
   {-# INLINE rule1675 #-}
   rule1675 = \ ((_recordExpressionBindingsIcollectWarnings) :: Warnings) ->
     _recordExpressionBindingsIcollectWarnings
   {-# INLINE rule1676 #-}
   rule1676 = \ _constraints ->
     _constraints
   {-# INLINE rule1677 #-}
   rule1677 = \ ((_recordExpressionBindingsIcounter) :: Int) ->
     _recordExpressionBindingsIcounter
   {-# INLINE rule1678 #-}
   rule1678 = \ ((_recordExpressionBindingsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _recordExpressionBindingsIdictionaryEnvironment
   {-# INLINE rule1679 #-}
   rule1679 = \ _infoTree ->
     _infoTree
   {-# INLINE rule1680 #-}
   rule1680 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1681 #-}
   rule1681 = \ _matches ->
     _matches
   {-# INLINE rule1682 #-}
   rule1682 = \ ((_recordExpressionBindingsIpatternMatchWarnings) :: [Warning]) ->
     _recordExpressionBindingsIpatternMatchWarnings
   {-# INLINE rule1683 #-}
   rule1683 = \ ((_recordExpressionBindingsIuniqueChunk) :: Int) ->
     _recordExpressionBindingsIuniqueChunk
   {-# INLINE rule1684 #-}
   rule1684 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1685 #-}
   rule1685 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1686 #-}
   rule1686 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1687 #-}
   rule1687 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1688 #-}
   rule1688 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1689 #-}
   rule1689 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1690 #-}
   rule1690 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1691 #-}
   rule1691 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1692 #-}
   rule1692 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1693 #-}
   rule1693 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1694 #-}
   rule1694 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1695 #-}
   rule1695 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1696 #-}
   rule1696 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1697 #-}
   rule1697 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1698 #-}
   rule1698 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1699 #-}
   rule1699 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Expression_RecordUpdate #-}
sem_Expression_RecordUpdate :: T_Range  -> T_Expression  -> T_RecordExpressionBindings  -> T_Expression 
sem_Expression_RecordUpdate arg_range_ arg_expression_ arg_recordExpressionBindings_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         _recordExpressionBindingsX140 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBindings (arg_recordExpressionBindings_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         (T_RecordExpressionBindings_vOut139 _recordExpressionBindingsIcollectErrors _recordExpressionBindingsIcollectInstances _recordExpressionBindingsIcollectWarnings _recordExpressionBindingsIcounter _recordExpressionBindingsIdictionaryEnvironment _recordExpressionBindingsIpatternMatchWarnings _recordExpressionBindingsIself _recordExpressionBindingsIunboundNames _recordExpressionBindingsIuniqueChunk) = inv_RecordExpressionBindings_s140 _recordExpressionBindingsX140 (T_RecordExpressionBindings_vIn139 _recordExpressionBindingsOallTypeSchemes _recordExpressionBindingsOavailablePredicates _recordExpressionBindingsOclassEnvironment _recordExpressionBindingsOcollectErrors _recordExpressionBindingsOcollectWarnings _recordExpressionBindingsOcounter _recordExpressionBindingsOcurrentChunk _recordExpressionBindingsOdictionaryEnvironment _recordExpressionBindingsOimportEnvironment _recordExpressionBindingsOnamesInScope _recordExpressionBindingsOorderedTypeSynonyms _recordExpressionBindingsOpatternMatchWarnings _recordExpressionBindingsOsubstitution _recordExpressionBindingsOtypeschemeMap _recordExpressionBindingsOuniqueChunk)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1700 _expressionIcollectInstances _recordExpressionBindingsIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1701 _expressionIunboundNames _recordExpressionBindingsIunboundNames
         _self = rule1702 _expressionIself _rangeIself _recordExpressionBindingsIself
         _lhsOself :: Expression
         _lhsOself = rule1703 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1704 _expressionIassumptions
         _lhsObeta :: Tp
         _lhsObeta = rule1705 _expressionIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1706 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1707 _recordExpressionBindingsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1708 _recordExpressionBindingsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule1709 _expressionIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule1710 _recordExpressionBindingsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1711 _recordExpressionBindingsIdictionaryEnvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1712 _expressionIinfoTree
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1713 _expressionImatchIO
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOmatches = rule1714 _expressionImatches
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1715 _recordExpressionBindingsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1716 _recordExpressionBindingsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1717 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule1718 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1719 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1720 _lhsIavailablePredicates
         _expressionObetaUnique = rule1721 _lhsIbetaUnique
         _expressionOclassEnvironment = rule1722 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1723 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1724 _lhsIcollectWarnings
         _expressionOcounter = rule1725 _lhsIcounter
         _expressionOcurrentChunk = rule1726 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1727 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1728 _lhsIimportEnvironment
         _expressionOmatchIO = rule1729 _lhsImatchIO
         _expressionOmonos = rule1730 _lhsImonos
         _expressionOnamesInScope = rule1731 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule1732 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1733 _lhsIparentTree
         _expressionOpatternMatchWarnings = rule1734 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule1735 _lhsIsubstitution
         _expressionOtryPatterns = rule1736 _lhsItryPatterns
         _expressionOtypeschemeMap = rule1737 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1738 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1739 _lhsIuniqueSecondRound
         _recordExpressionBindingsOallTypeSchemes = rule1740 _lhsIallTypeSchemes
         _recordExpressionBindingsOavailablePredicates = rule1741 _lhsIavailablePredicates
         _recordExpressionBindingsOclassEnvironment = rule1742 _lhsIclassEnvironment
         _recordExpressionBindingsOcollectErrors = rule1743 _expressionIcollectErrors
         _recordExpressionBindingsOcollectWarnings = rule1744 _expressionIcollectWarnings
         _recordExpressionBindingsOcounter = rule1745 _expressionIcounter
         _recordExpressionBindingsOcurrentChunk = rule1746 _lhsIcurrentChunk
         _recordExpressionBindingsOdictionaryEnvironment = rule1747 _expressionIdictionaryEnvironment
         _recordExpressionBindingsOimportEnvironment = rule1748 _lhsIimportEnvironment
         _recordExpressionBindingsOnamesInScope = rule1749 _lhsInamesInScope
         _recordExpressionBindingsOorderedTypeSynonyms = rule1750 _lhsIorderedTypeSynonyms
         _recordExpressionBindingsOpatternMatchWarnings = rule1751 _expressionIpatternMatchWarnings
         _recordExpressionBindingsOsubstitution = rule1752 _lhsIsubstitution
         _recordExpressionBindingsOtypeschemeMap = rule1753 _lhsItypeschemeMap
         _recordExpressionBindingsOuniqueChunk = rule1754 _expressionIuniqueChunk
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1700 #-}
   rule1700 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_recordExpressionBindingsIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances  ++  _recordExpressionBindingsIcollectInstances
   {-# INLINE rule1701 #-}
   rule1701 = \ ((_expressionIunboundNames) :: Names) ((_recordExpressionBindingsIunboundNames) :: Names) ->
     _expressionIunboundNames ++ _recordExpressionBindingsIunboundNames
   {-# INLINE rule1702 #-}
   rule1702 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ((_recordExpressionBindingsIself) :: RecordExpressionBindings) ->
     Expression_RecordUpdate _rangeIself _expressionIself _recordExpressionBindingsIself
   {-# INLINE rule1703 #-}
   rule1703 = \ _self ->
     _self
   {-# INLINE rule1704 #-}
   rule1704 = \ ((_expressionIassumptions) :: Assumptions) ->
     _expressionIassumptions
   {-# INLINE rule1705 #-}
   rule1705 = \ ((_expressionIbeta) :: Tp) ->
     _expressionIbeta
   {-# INLINE rule1706 #-}
   rule1706 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1707 #-}
   rule1707 = \ ((_recordExpressionBindingsIcollectErrors) :: TypeErrors) ->
     _recordExpressionBindingsIcollectErrors
   {-# INLINE rule1708 #-}
   rule1708 = \ ((_recordExpressionBindingsIcollectWarnings) :: Warnings) ->
     _recordExpressionBindingsIcollectWarnings
   {-# INLINE rule1709 #-}
   rule1709 = \ ((_expressionIconstraints) :: ConstraintSet) ->
     _expressionIconstraints
   {-# INLINE rule1710 #-}
   rule1710 = \ ((_recordExpressionBindingsIcounter) :: Int) ->
     _recordExpressionBindingsIcounter
   {-# INLINE rule1711 #-}
   rule1711 = \ ((_recordExpressionBindingsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _recordExpressionBindingsIdictionaryEnvironment
   {-# INLINE rule1712 #-}
   rule1712 = \ ((_expressionIinfoTree) :: InfoTree) ->
     _expressionIinfoTree
   {-# INLINE rule1713 #-}
   rule1713 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule1714 #-}
   rule1714 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ->
     _expressionImatches
   {-# INLINE rule1715 #-}
   rule1715 = \ ((_recordExpressionBindingsIpatternMatchWarnings) :: [Warning]) ->
     _recordExpressionBindingsIpatternMatchWarnings
   {-# INLINE rule1716 #-}
   rule1716 = \ ((_recordExpressionBindingsIuniqueChunk) :: Int) ->
     _recordExpressionBindingsIuniqueChunk
   {-# INLINE rule1717 #-}
   rule1717 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule1718 #-}
   rule1718 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1719 #-}
   rule1719 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1720 #-}
   rule1720 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1721 #-}
   rule1721 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule1722 #-}
   rule1722 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1723 #-}
   rule1723 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1724 #-}
   rule1724 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1725 #-}
   rule1725 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1726 #-}
   rule1726 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1727 #-}
   rule1727 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1728 #-}
   rule1728 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1729 #-}
   rule1729 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1730 #-}
   rule1730 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1731 #-}
   rule1731 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1732 #-}
   rule1732 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1733 #-}
   rule1733 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule1734 #-}
   rule1734 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1735 #-}
   rule1735 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1736 #-}
   rule1736 = \ ((_lhsItryPatterns) :: [(Expression     , [String])]) ->
     _lhsItryPatterns
   {-# INLINE rule1737 #-}
   rule1737 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1738 #-}
   rule1738 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1739 #-}
   rule1739 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1740 #-}
   rule1740 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1741 #-}
   rule1741 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1742 #-}
   rule1742 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1743 #-}
   rule1743 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1744 #-}
   rule1744 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1745 #-}
   rule1745 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1746 #-}
   rule1746 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1747 #-}
   rule1747 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1748 #-}
   rule1748 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1749 #-}
   rule1749 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1750 #-}
   rule1750 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1751 #-}
   rule1751 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1752 #-}
   rule1752 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1753 #-}
   rule1753 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1754 #-}
   rule1754 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
{-# NOINLINE sem_Expression_Enum #-}
sem_Expression_Enum :: T_Range  -> T_Expression  -> T_MaybeExpression  -> T_MaybeExpression  -> T_Expression 
sem_Expression_Enum arg_range_ arg_from_ arg_then_ arg_to_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _fromX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_from_))
         _thenX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_then_))
         _toX95 = Control.Monad.Identity.runIdentity (attach_T_MaybeExpression (arg_to_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _fromIassumptions _fromIbeta _fromIbetaUnique _fromIcollectErrors _fromIcollectInstances _fromIcollectWarnings _fromIconstraints _fromIcounter _fromIdictionaryEnvironment _fromIinfoTree _fromImatchIO _fromImatches _fromIpatternMatchWarnings _fromIself _fromIunboundNames _fromIuniqueChunk _fromIuniqueSecondRound) = inv_Expression_s41 _fromX41 (T_Expression_vIn40 _fromOallPatterns _fromOallTypeSchemes _fromOavailablePredicates _fromObetaUnique _fromOclassEnvironment _fromOcollectErrors _fromOcollectWarnings _fromOcounter _fromOcurrentChunk _fromOdictionaryEnvironment _fromOimportEnvironment _fromOmatchIO _fromOmonos _fromOnamesInScope _fromOorderedTypeSynonyms _fromOparentTree _fromOpatternMatchWarnings _fromOsubstitution _fromOtryPatterns _fromOtypeschemeMap _fromOuniqueChunk _fromOuniqueSecondRound)
         (T_MaybeExpression_vOut94 _thenIassumptions _thenIbeta _thenIbetaUnique _thenIcollectErrors _thenIcollectInstances _thenIcollectWarnings _thenIconstraints _thenIcounter _thenIdictionaryEnvironment _thenIinfoTrees _thenImatchIO _thenImatches _thenIpatternMatchWarnings _thenIsection _thenIself _thenIunboundNames _thenIuniqueChunk _thenIuniqueSecondRound) = inv_MaybeExpression_s95 _thenX95 (T_MaybeExpression_vIn94 _thenOallPatterns _thenOallTypeSchemes _thenOavailablePredicates _thenObetaUnique _thenOclassEnvironment _thenOcollectErrors _thenOcollectWarnings _thenOcounter _thenOcurrentChunk _thenOdictionaryEnvironment _thenOimportEnvironment _thenOmatchIO _thenOmonos _thenOnamesInScope _thenOorderedTypeSynonyms _thenOparentTree _thenOpatternMatchWarnings _thenOsubstitution _thenOtryPatterns _thenOtypeschemeMap _thenOuniqueChunk _thenOuniqueSecondRound)
         (T_MaybeExpression_vOut94 _toIassumptions _toIbeta _toIbetaUnique _toIcollectErrors _toIcollectInstances _toIcollectWarnings _toIconstraints _toIcounter _toIdictionaryEnvironment _toIinfoTrees _toImatchIO _toImatches _toIpatternMatchWarnings _toIsection _toIself _toIunboundNames _toIuniqueChunk _toIuniqueSecondRound) = inv_MaybeExpression_s95 _toX95 (T_MaybeExpression_vIn94 _toOallPatterns _toOallTypeSchemes _toOavailablePredicates _toObetaUnique _toOclassEnvironment _toOcollectErrors _toOcollectWarnings _toOcounter _toOcurrentChunk _toOdictionaryEnvironment _toOimportEnvironment _toOmatchIO _toOmonos _toOnamesInScope _toOorderedTypeSynonyms _toOparentTree _toOpatternMatchWarnings _toOsubstitution _toOtryPatterns _toOtypeschemeMap _toOuniqueChunk _toOuniqueSecondRound)
         _fromObetaUnique = rule1755 _lhsIbetaUnique _overloaded
         _assumptions = rule1756 _fromIassumptions _thenIassumptions _toIassumptions
         _constraints = rule1757 _conFrom _conList _conPredicate _conThen _conTo _fromIconstraints _thenIconstraints _toIconstraints
         _beta = rule1758 _lhsIbetaUnique
         _overloaded = rule1759 _lhsIimportEnvironment
         _elementType = rule1760 _lhsIbetaUnique _overloaded
         _conPredicate = rule1761 _cinfoPred _elementType _overloaded
         _conList = rule1762 _beta _cinfoResult _elementType
         _conFrom = rule1763 _cinfoFrom _elementType _fromIbeta
         _conThen = rule1764 _cinfoThen _elementType _thenIbeta
         _conTo = rule1765 _cinfoTo _elementType _toIbeta
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1766 _newDEnv
         _localName = rule1767 _rangeIself _thenIsection _toIsection
         _requiredDictionaries = rule1768 _elementType _lhsIsubstitution _overloaded
         _newDEnv = rule1769 _lhsIavailablePredicates _lhsIclassEnvironment _lhsIsubstitution _localName _requiredDictionaries _toIdictionaryEnvironment
         _cinfoFrom = rule1770 _parentTree
         _cinfoThen = rule1771 _parentTree
         _toChildNr = rule1772 _thenIinfoTrees
         _cinfoTo = rule1773 _parentTree _toChildNr
         _cinfoResult = rule1774 _parentTree
         _cinfoPred = rule1775 _elementType _parentTree
         _localInfo = rule1776 _beta _lhsImonos _self
         _parentTree = rule1777 _fromIinfoTree _lhsIparentTree _localInfo _thenIinfoTrees _toIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1778 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         ((_fromOtryPatterns,_thenOtryPatterns,_toOtryPatterns),_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1779 _assumptions _constraints _fromImatches _lhsIallPatterns _lhsItryPatterns _localInfo _thenImatches _toImatches _toIuniqueSecondRound
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1780 _ioMatch _toImatchIO
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1781 _fromIcollectInstances _thenIcollectInstances _toIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1782 _fromIunboundNames _thenIunboundNames _toIunboundNames
         _self = rule1783 _fromIself _rangeIself _thenIself _toIself
         _lhsOself :: Expression
         _lhsOself = rule1784 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1785 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1786 _toIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1787 _toIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1788 _toIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1789 _toIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1790 _toIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1791 _toIuniqueChunk
         _fromOallPatterns = rule1792 _lhsIallPatterns
         _fromOallTypeSchemes = rule1793 _lhsIallTypeSchemes
         _fromOavailablePredicates = rule1794 _lhsIavailablePredicates
         _fromOclassEnvironment = rule1795 _lhsIclassEnvironment
         _fromOcollectErrors = rule1796 _lhsIcollectErrors
         _fromOcollectWarnings = rule1797 _lhsIcollectWarnings
         _fromOcounter = rule1798 _lhsIcounter
         _fromOcurrentChunk = rule1799 _lhsIcurrentChunk
         _fromOdictionaryEnvironment = rule1800 _lhsIdictionaryEnvironment
         _fromOimportEnvironment = rule1801 _lhsIimportEnvironment
         _fromOmatchIO = rule1802 _lhsImatchIO
         _fromOmonos = rule1803 _lhsImonos
         _fromOnamesInScope = rule1804 _lhsInamesInScope
         _fromOorderedTypeSynonyms = rule1805 _lhsIorderedTypeSynonyms
         _fromOparentTree = rule1806 _parentTree
         _fromOpatternMatchWarnings = rule1807 _lhsIpatternMatchWarnings
         _fromOsubstitution = rule1808 _lhsIsubstitution
         _fromOtypeschemeMap = rule1809 _lhsItypeschemeMap
         _fromOuniqueChunk = rule1810 _lhsIuniqueChunk
         _fromOuniqueSecondRound = rule1811 _lhsIuniqueSecondRound
         _thenOallPatterns = rule1812 _lhsIallPatterns
         _thenOallTypeSchemes = rule1813 _lhsIallTypeSchemes
         _thenOavailablePredicates = rule1814 _lhsIavailablePredicates
         _thenObetaUnique = rule1815 _fromIbetaUnique
         _thenOclassEnvironment = rule1816 _lhsIclassEnvironment
         _thenOcollectErrors = rule1817 _fromIcollectErrors
         _thenOcollectWarnings = rule1818 _fromIcollectWarnings
         _thenOcounter = rule1819 _fromIcounter
         _thenOcurrentChunk = rule1820 _lhsIcurrentChunk
         _thenOdictionaryEnvironment = rule1821 _fromIdictionaryEnvironment
         _thenOimportEnvironment = rule1822 _lhsIimportEnvironment
         _thenOmatchIO = rule1823 _fromImatchIO
         _thenOmonos = rule1824 _lhsImonos
         _thenOnamesInScope = rule1825 _lhsInamesInScope
         _thenOorderedTypeSynonyms = rule1826 _lhsIorderedTypeSynonyms
         _thenOparentTree = rule1827 _parentTree
         _thenOpatternMatchWarnings = rule1828 _fromIpatternMatchWarnings
         _thenOsubstitution = rule1829 _lhsIsubstitution
         _thenOtypeschemeMap = rule1830 _lhsItypeschemeMap
         _thenOuniqueChunk = rule1831 _fromIuniqueChunk
         _thenOuniqueSecondRound = rule1832 _fromIuniqueSecondRound
         _toOallPatterns = rule1833 _lhsIallPatterns
         _toOallTypeSchemes = rule1834 _lhsIallTypeSchemes
         _toOavailablePredicates = rule1835 _lhsIavailablePredicates
         _toObetaUnique = rule1836 _thenIbetaUnique
         _toOclassEnvironment = rule1837 _lhsIclassEnvironment
         _toOcollectErrors = rule1838 _thenIcollectErrors
         _toOcollectWarnings = rule1839 _thenIcollectWarnings
         _toOcounter = rule1840 _thenIcounter
         _toOcurrentChunk = rule1841 _lhsIcurrentChunk
         _toOdictionaryEnvironment = rule1842 _thenIdictionaryEnvironment
         _toOimportEnvironment = rule1843 _lhsIimportEnvironment
         _toOmatchIO = rule1844 _thenImatchIO
         _toOmonos = rule1845 _lhsImonos
         _toOnamesInScope = rule1846 _lhsInamesInScope
         _toOorderedTypeSynonyms = rule1847 _lhsIorderedTypeSynonyms
         _toOparentTree = rule1848 _parentTree
         _toOpatternMatchWarnings = rule1849 _thenIpatternMatchWarnings
         _toOsubstitution = rule1850 _lhsIsubstitution
         _toOtypeschemeMap = rule1851 _lhsItypeschemeMap
         _toOuniqueChunk = rule1852 _thenIuniqueChunk
         _toOuniqueSecondRound = rule1853 _thenIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1755 #-}
   rule1755 = \ ((_lhsIbetaUnique) :: Int) _overloaded ->
                               _lhsIbetaUnique + (if _overloaded then 2 else 1)
   {-# INLINE rule1756 #-}
   rule1756 = \ ((_fromIassumptions) :: Assumptions) ((_thenIassumptions) :: Assumptions) ((_toIassumptions) :: Assumptions) ->
                               _fromIassumptions `combine` _thenIassumptions `combine` _toIassumptions
   {-# INLINE rule1757 #-}
   rule1757 = \ _conFrom _conList _conPredicate _conThen _conTo ((_fromIconstraints) :: ConstraintSet) ((_thenIconstraints) :: ConstraintSet) ((_toIconstraints) :: ConstraintSet) ->
                               (_conList ++ _conPredicate) .>.
                               Node [ _conFrom .<. _fromIconstraints
                                    , _conThen .<. _thenIconstraints
                                    , _conTo   .<. _toIconstraints
                                    ]
   {-# INLINE rule1758 #-}
   rule1758 = \ ((_lhsIbetaUnique) :: Int) ->
                               TVar _lhsIbetaUnique
   {-# INLINE rule1759 #-}
   rule1759 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                               case M.lookup enumFromName (typeEnvironment _lhsIimportEnvironment) of
                                  Just scheme -> isOverloaded scheme
                                  Nothing     -> False
   {-# INLINE rule1760 #-}
   rule1760 = \ ((_lhsIbetaUnique) :: Int) _overloaded ->
                               if _overloaded then TVar (_lhsIbetaUnique + 1) else intType
   {-# INLINE rule1761 #-}
   rule1761 = \ _cinfoPred _elementType _overloaded ->
                               if _overloaded then [predicate (Predicate "Enum" _elementType) _cinfoPred] else []
   {-# INLINE rule1762 #-}
   rule1762 = \ _beta _cinfoResult _elementType ->
                               [ (listType _elementType .==. _beta) _cinfoResult ]
   {-# INLINE rule1763 #-}
   rule1763 = \ _cinfoFrom _elementType ((_fromIbeta) :: Tp) ->
                               [ (_fromIbeta .==. _elementType) _cinfoFrom ]
   {-# INLINE rule1764 #-}
   rule1764 = \ _cinfoThen _elementType ((_thenIbeta) :: Tp) ->
                               [ (_thenIbeta .==. _elementType) _cinfoThen ]
   {-# INLINE rule1765 #-}
   rule1765 = \ _cinfoTo _elementType ((_toIbeta) :: Tp) ->
                               [ (_toIbeta   .==. _elementType) _cinfoTo   ]
   {-# INLINE rule1766 #-}
   rule1766 = \ _newDEnv ->
                                             _newDEnv
   {-# INLINE rule1767 #-}
   rule1767 = \ ((_rangeIself) :: Range) ((_thenIsection) :: Bool) ((_toIsection) :: Bool) ->
                                             flip setNameRange _rangeIself $
                                             case (_thenIsection, _toIsection) of
                                                (False, False) -> enumFromThenToName
                                                (False, True ) -> enumFromThenName
                                                (True , False) -> enumFromToName
                                                (True , True ) -> enumFromName
   {-# INLINE rule1768 #-}
   rule1768 = \ _elementType ((_lhsIsubstitution) :: FixpointSubstitution) _overloaded ->
                                             if _overloaded then _lhsIsubstitution |-> [Predicate "Enum" _elementType] else []
   {-# INLINE rule1769 #-}
   rule1769 = \ ((_lhsIavailablePredicates) :: Predicates) ((_lhsIclassEnvironment) :: ClassEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _localName _requiredDictionaries ((_toIdictionaryEnvironment) :: DictionaryEnvironment) ->
                                             resolveOverloading (_lhsIclassEnvironment)  _localName
                                                                (_lhsIsubstitution |-> _lhsIavailablePredicates)
                                                                (_lhsIsubstitution |-> _requiredDictionaries)
                                                                _toIdictionaryEnvironment
   {-# INLINE rule1770 #-}
   rule1770 = \ _parentTree ->
     childConstraint 0 "enumeration" _parentTree
        []
   {-# INLINE rule1771 #-}
   rule1771 = \ _parentTree ->
     childConstraint 1 "enumeration" _parentTree
        []
   {-# INLINE rule1772 #-}
   rule1772 = \ ((_thenIinfoTrees) :: InfoTrees) ->
                                          1 + length _thenIinfoTrees
   {-# INLINE rule1773 #-}
   rule1773 = \ _parentTree _toChildNr ->
     childConstraint _toChildNr "enumeration" _parentTree
        []
   {-# INLINE rule1774 #-}
   rule1774 = \ _parentTree ->
     resultConstraint "enumeration" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule1775 #-}
   rule1775 = \ _elementType _parentTree ->
     resultConstraint "enumeration" _parentTree
        [ ReductionErrorInfo (Predicate "Enum" _elementType) ]
   {-# INLINE rule1776 #-}
   rule1776 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1777 #-}
   rule1777 = \ ((_fromIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_thenIinfoTrees) :: InfoTrees) ((_toIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo (_fromIinfoTree : _thenIinfoTrees ++ _toIinfoTrees)
   {-# INLINE rule1778 #-}
   rule1778 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1779 #-}
   rule1779 = \ _assumptions _constraints ((_fromImatches) :: [Maybe MetaVariableTable]) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ((_thenImatches) :: [Maybe MetaVariableTable]) ((_toImatches) :: [Maybe MetaVariableTable]) ((_toIuniqueSecondRound) :: Int) ->
             let infoTuple = metaVarInfo _constraints _assumptions _localInfo
             in match3 infoTuple _toIuniqueSecondRound
                       match_Expression_Enum
                       _lhsItryPatterns _lhsIallPatterns
                       [_fromImatches, _thenImatches, _toImatches]
   {-# INLINE rule1780 #-}
   rule1780 = \ _ioMatch ((_toImatchIO) :: IO ()) ->
                                       _toImatchIO              >> _ioMatch
   {-# INLINE rule1781 #-}
   rule1781 = \ ((_fromIcollectInstances) :: [(Name, Instance)]) ((_thenIcollectInstances) :: [(Name, Instance)]) ((_toIcollectInstances) :: [(Name, Instance)]) ->
     _fromIcollectInstances  ++  _thenIcollectInstances  ++  _toIcollectInstances
   {-# INLINE rule1782 #-}
   rule1782 = \ ((_fromIunboundNames) :: Names) ((_thenIunboundNames) :: Names) ((_toIunboundNames) :: Names) ->
     _fromIunboundNames ++ _thenIunboundNames ++ _toIunboundNames
   {-# INLINE rule1783 #-}
   rule1783 = \ ((_fromIself) :: Expression) ((_rangeIself) :: Range) ((_thenIself) :: MaybeExpression) ((_toIself) :: MaybeExpression) ->
     Expression_Enum _rangeIself _fromIself _thenIself _toIself
   {-# INLINE rule1784 #-}
   rule1784 = \ _self ->
     _self
   {-# INLINE rule1785 #-}
   rule1785 = \ _beta ->
     _beta
   {-# INLINE rule1786 #-}
   rule1786 = \ ((_toIbetaUnique) :: Int) ->
     _toIbetaUnique
   {-# INLINE rule1787 #-}
   rule1787 = \ ((_toIcollectErrors) :: TypeErrors) ->
     _toIcollectErrors
   {-# INLINE rule1788 #-}
   rule1788 = \ ((_toIcollectWarnings) :: Warnings) ->
     _toIcollectWarnings
   {-# INLINE rule1789 #-}
   rule1789 = \ ((_toIcounter) :: Int) ->
     _toIcounter
   {-# INLINE rule1790 #-}
   rule1790 = \ ((_toIpatternMatchWarnings) :: [Warning]) ->
     _toIpatternMatchWarnings
   {-# INLINE rule1791 #-}
   rule1791 = \ ((_toIuniqueChunk) :: Int) ->
     _toIuniqueChunk
   {-# INLINE rule1792 #-}
   rule1792 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1793 #-}
   rule1793 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1794 #-}
   rule1794 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1795 #-}
   rule1795 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1796 #-}
   rule1796 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1797 #-}
   rule1797 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1798 #-}
   rule1798 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1799 #-}
   rule1799 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1800 #-}
   rule1800 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1801 #-}
   rule1801 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1802 #-}
   rule1802 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1803 #-}
   rule1803 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1804 #-}
   rule1804 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1805 #-}
   rule1805 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1806 #-}
   rule1806 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1807 #-}
   rule1807 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1808 #-}
   rule1808 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1809 #-}
   rule1809 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1810 #-}
   rule1810 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1811 #-}
   rule1811 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1812 #-}
   rule1812 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1813 #-}
   rule1813 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1814 #-}
   rule1814 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1815 #-}
   rule1815 = \ ((_fromIbetaUnique) :: Int) ->
     _fromIbetaUnique
   {-# INLINE rule1816 #-}
   rule1816 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1817 #-}
   rule1817 = \ ((_fromIcollectErrors) :: TypeErrors) ->
     _fromIcollectErrors
   {-# INLINE rule1818 #-}
   rule1818 = \ ((_fromIcollectWarnings) :: Warnings) ->
     _fromIcollectWarnings
   {-# INLINE rule1819 #-}
   rule1819 = \ ((_fromIcounter) :: Int) ->
     _fromIcounter
   {-# INLINE rule1820 #-}
   rule1820 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1821 #-}
   rule1821 = \ ((_fromIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _fromIdictionaryEnvironment
   {-# INLINE rule1822 #-}
   rule1822 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1823 #-}
   rule1823 = \ ((_fromImatchIO) :: IO ()) ->
     _fromImatchIO
   {-# INLINE rule1824 #-}
   rule1824 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1825 #-}
   rule1825 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1826 #-}
   rule1826 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1827 #-}
   rule1827 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1828 #-}
   rule1828 = \ ((_fromIpatternMatchWarnings) :: [Warning]) ->
     _fromIpatternMatchWarnings
   {-# INLINE rule1829 #-}
   rule1829 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1830 #-}
   rule1830 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1831 #-}
   rule1831 = \ ((_fromIuniqueChunk) :: Int) ->
     _fromIuniqueChunk
   {-# INLINE rule1832 #-}
   rule1832 = \ ((_fromIuniqueSecondRound) :: Int) ->
     _fromIuniqueSecondRound
   {-# INLINE rule1833 #-}
   rule1833 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1834 #-}
   rule1834 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1835 #-}
   rule1835 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1836 #-}
   rule1836 = \ ((_thenIbetaUnique) :: Int) ->
     _thenIbetaUnique
   {-# INLINE rule1837 #-}
   rule1837 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1838 #-}
   rule1838 = \ ((_thenIcollectErrors) :: TypeErrors) ->
     _thenIcollectErrors
   {-# INLINE rule1839 #-}
   rule1839 = \ ((_thenIcollectWarnings) :: Warnings) ->
     _thenIcollectWarnings
   {-# INLINE rule1840 #-}
   rule1840 = \ ((_thenIcounter) :: Int) ->
     _thenIcounter
   {-# INLINE rule1841 #-}
   rule1841 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1842 #-}
   rule1842 = \ ((_thenIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _thenIdictionaryEnvironment
   {-# INLINE rule1843 #-}
   rule1843 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1844 #-}
   rule1844 = \ ((_thenImatchIO) :: IO ()) ->
     _thenImatchIO
   {-# INLINE rule1845 #-}
   rule1845 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1846 #-}
   rule1846 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1847 #-}
   rule1847 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1848 #-}
   rule1848 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1849 #-}
   rule1849 = \ ((_thenIpatternMatchWarnings) :: [Warning]) ->
     _thenIpatternMatchWarnings
   {-# INLINE rule1850 #-}
   rule1850 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1851 #-}
   rule1851 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1852 #-}
   rule1852 = \ ((_thenIuniqueChunk) :: Int) ->
     _thenIuniqueChunk
   {-# INLINE rule1853 #-}
   rule1853 = \ ((_thenIuniqueSecondRound) :: Int) ->
     _thenIuniqueSecondRound
{-# NOINLINE sem_Expression_Negate #-}
sem_Expression_Negate :: T_Range  -> T_Expression  -> T_Expression 
sem_Expression_Negate arg_range_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _expressionObetaUnique = rule1854 _lhsIbetaUnique
         _constraints = rule1855 _expressionIconstraints _newcon
         _beta = rule1856 _lhsIbetaUnique
         _newcon = rule1857 _beta _cinfo _expressionIbeta _lhsIimportEnvironment
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1858 _newDEnv
         _localName = rule1859 _rangeIself
         _negateTypeScheme = rule1860 _lhsIimportEnvironment _localName
         _requiredDictionaries = rule1861 _lhsIimportEnvironment _lhsIsubstitution _negateTypeScheme _usedAsType
         _usedAsType = rule1862 _beta _expressionIbeta _lhsIsubstitution
         _newDEnv = rule1863 _expressionIdictionaryEnvironment _lhsIavailablePredicates _lhsIclassEnvironment _lhsIsubstitution _localName _requiredDictionaries
         _cinfo = rule1864 _localInfo _parentTree _rangeIself
         _localInfo = rule1865 _beta _lhsImonos _self
         _parentTree = rule1866 _expressionIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1867 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         (_expressionOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1868 _constraints _expressionIassumptions _expressionImatches _expressionIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1869 _expressionImatchIO _ioMatch
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1870 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1871 _expressionIunboundNames
         _self = rule1872 _expressionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1873 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1874 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1875 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1876 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1877 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1878 _expressionIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1879 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1880 _expressionIuniqueChunk
         _expressionOallPatterns = rule1881 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1882 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1883 _lhsIavailablePredicates
         _expressionOclassEnvironment = rule1884 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1885 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1886 _lhsIcollectWarnings
         _expressionOcounter = rule1887 _lhsIcounter
         _expressionOcurrentChunk = rule1888 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1889 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1890 _lhsIimportEnvironment
         _expressionOmatchIO = rule1891 _lhsImatchIO
         _expressionOmonos = rule1892 _lhsImonos
         _expressionOnamesInScope = rule1893 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule1894 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1895 _parentTree
         _expressionOpatternMatchWarnings = rule1896 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule1897 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1898 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1899 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1900 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1854 #-}
   rule1854 = \ ((_lhsIbetaUnique) :: Int) ->
                                    _lhsIbetaUnique + 1
   {-# INLINE rule1855 #-}
   rule1855 = \ ((_expressionIconstraints) :: ConstraintSet) _newcon ->
                                    _newcon .>. Node [ _expressionIconstraints ]
   {-# INLINE rule1856 #-}
   rule1856 = \ ((_lhsIbetaUnique) :: Int) ->
                                    TVar _lhsIbetaUnique
   {-# INLINE rule1857 #-}
   rule1857 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                    let standard = makeScheme [] [Predicate "Num" (TVar 0)] (TVar 0 .->. TVar 0)
                                        tpscheme = M.findWithDefault standard (nameFromString "negate") (typeEnvironment _lhsIimportEnvironment)
                                    in [ (_expressionIbeta .->. _beta .::. tpscheme) _cinfo]
   {-# INLINE rule1858 #-}
   rule1858 = \ _newDEnv ->
                                             _newDEnv
   {-# INLINE rule1859 #-}
   rule1859 = \ ((_rangeIself) :: Range) ->
                                             setNameRange intUnaryMinusName _rangeIself
   {-# INLINE rule1860 #-}
   rule1860 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) _localName ->
                                             case M.lookup _localName (typeEnvironment _lhsIimportEnvironment) of
                                                Just scheme -> scheme
                                                Nothing     -> internalError "TypeInferenceOverloading.ag" "n/a" "type of negate unknown"
   {-# INLINE rule1861 #-}
   rule1861 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _negateTypeScheme _usedAsType ->
                                             getRequiredDictionaries
                                                (getOrderedTypeSynonyms _lhsIimportEnvironment)
                                                (_lhsIsubstitution |-> _usedAsType)
                                                (_lhsIsubstitution |-> _negateTypeScheme)
   {-# INLINE rule1862 #-}
   rule1862 = \ _beta ((_expressionIbeta) :: Tp) ((_lhsIsubstitution) :: FixpointSubstitution) ->
                                             _lhsIsubstitution |-> (_expressionIbeta .->. _beta)
   {-# INLINE rule1863 #-}
   rule1863 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ((_lhsIavailablePredicates) :: Predicates) ((_lhsIclassEnvironment) :: ClassEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) _localName _requiredDictionaries ->
                                             resolveOverloading (_lhsIclassEnvironment)  _localName
                                                                (_lhsIsubstitution |-> _lhsIavailablePredicates)
                                                                (_lhsIsubstitution |-> _requiredDictionaries)
                                                                _expressionIdictionaryEnvironment
   {-# INLINE rule1864 #-}
   rule1864 = \ _localInfo _parentTree ((_rangeIself) :: Range) ->
     specialConstraint "negation" _parentTree
        (self _localInfo, Just $ nameToUHA_Expr (Name_Operator _rangeIself [] "-"))
        []
   {-# INLINE rule1865 #-}
   rule1865 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1866 #-}
   rule1866 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_expressionIinfoTree]
   {-# INLINE rule1867 #-}
   rule1867 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1868 #-}
   rule1868 = \ _constraints ((_expressionIassumptions) :: Assumptions) ((_expressionImatches) :: [Maybe MetaVariableTable]) ((_expressionIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _expressionIassumptions _localInfo
            in match1 infoTuple _expressionIuniqueSecondRound
                      match_Expression_Negate
                      _lhsItryPatterns _lhsIallPatterns
                      [_expressionImatches]
   {-# INLINE rule1869 #-}
   rule1869 = \ ((_expressionImatchIO) :: IO ()) _ioMatch ->
                                       _expressionImatchIO      >> _ioMatch
   {-# INLINE rule1870 #-}
   rule1870 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule1871 #-}
   rule1871 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule1872 #-}
   rule1872 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_Negate _rangeIself _expressionIself
   {-# INLINE rule1873 #-}
   rule1873 = \ _self ->
     _self
   {-# INLINE rule1874 #-}
   rule1874 = \ _beta ->
     _beta
   {-# INLINE rule1875 #-}
   rule1875 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1876 #-}
   rule1876 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1877 #-}
   rule1877 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1878 #-}
   rule1878 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1879 #-}
   rule1879 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1880 #-}
   rule1880 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule1881 #-}
   rule1881 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1882 #-}
   rule1882 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1883 #-}
   rule1883 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1884 #-}
   rule1884 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1885 #-}
   rule1885 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1886 #-}
   rule1886 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1887 #-}
   rule1887 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1888 #-}
   rule1888 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1889 #-}
   rule1889 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1890 #-}
   rule1890 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1891 #-}
   rule1891 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1892 #-}
   rule1892 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1893 #-}
   rule1893 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1894 #-}
   rule1894 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1895 #-}
   rule1895 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1896 #-}
   rule1896 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1897 #-}
   rule1897 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1898 #-}
   rule1898 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1899 #-}
   rule1899 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1900 #-}
   rule1900 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Expression_NegateFloat #-}
sem_Expression_NegateFloat :: T_Range  -> T_Expression  -> T_Expression 
sem_Expression_NegateFloat arg_range_ arg_expression_ = T_Expression (return st41) where
   {-# NOINLINE st41 #-}
   st41 = let
      v40 :: T_Expression_v40 
      v40 = \ (T_Expression_vIn40 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _expressionObetaUnique = rule1901 _lhsIbetaUnique
         _constraints = rule1902 _expressionIconstraints _newcon
         _beta = rule1903 _lhsIbetaUnique
         _newcon = rule1904 _beta _cinfo _expressionIbeta
         _cinfo = rule1905 _localInfo _parentTree _rangeIself
         _localInfo = rule1906 _beta _lhsImonos _self
         _parentTree = rule1907 _expressionIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule1908 _parentTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         _lhsOconstraints :: ConstraintSet
         _lhsOassumptions :: Assumptions
         _lhsOuniqueSecondRound :: Int
         (_expressionOtryPatterns,_lhsOmatches,_lhsOconstraints,_lhsOassumptions,_lhsOuniqueSecondRound,_ioMatch) = rule1909 _constraints _expressionIassumptions _expressionImatches _expressionIuniqueSecondRound _lhsIallPatterns _lhsItryPatterns _localInfo
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1910 _expressionImatchIO _ioMatch
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1911 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1912 _expressionIunboundNames
         _self = rule1913 _expressionIself _rangeIself
         _lhsOself :: Expression
         _lhsOself = rule1914 _self
         _lhsObeta :: Tp
         _lhsObeta = rule1915 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1916 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1917 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1918 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1919 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1920 _expressionIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1921 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1922 _expressionIuniqueChunk
         _expressionOallPatterns = rule1923 _lhsIallPatterns
         _expressionOallTypeSchemes = rule1924 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule1925 _lhsIavailablePredicates
         _expressionOclassEnvironment = rule1926 _lhsIclassEnvironment
         _expressionOcollectErrors = rule1927 _lhsIcollectErrors
         _expressionOcollectWarnings = rule1928 _lhsIcollectWarnings
         _expressionOcounter = rule1929 _lhsIcounter
         _expressionOcurrentChunk = rule1930 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule1931 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule1932 _lhsIimportEnvironment
         _expressionOmatchIO = rule1933 _lhsImatchIO
         _expressionOmonos = rule1934 _lhsImonos
         _expressionOnamesInScope = rule1935 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule1936 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule1937 _parentTree
         _expressionOpatternMatchWarnings = rule1938 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule1939 _lhsIsubstitution
         _expressionOtypeschemeMap = rule1940 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule1941 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule1942 _lhsIuniqueSecondRound
         __result_ = T_Expression_vOut40 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expression_s41 v40
   {-# INLINE rule1901 #-}
   rule1901 = \ ((_lhsIbetaUnique) :: Int) ->
                                    _lhsIbetaUnique + 1
   {-# INLINE rule1902 #-}
   rule1902 = \ ((_expressionIconstraints) :: ConstraintSet) _newcon ->
                                    _newcon .>. Node [ _expressionIconstraints ]
   {-# INLINE rule1903 #-}
   rule1903 = \ ((_lhsIbetaUnique) :: Int) ->
                                    TVar _lhsIbetaUnique
   {-# INLINE rule1904 #-}
   rule1904 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ->
                                    [ (floatType .->. floatType .==. _expressionIbeta .->. _beta) _cinfo]
   {-# INLINE rule1905 #-}
   rule1905 = \ _localInfo _parentTree ((_rangeIself) :: Range) ->
     specialConstraint "negation" _parentTree
        (self _localInfo, Just $ nameToUHA_Expr (Name_Operator _rangeIself [] "-."))
        []
   {-# INLINE rule1906 #-}
   rule1906 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Expr _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule1907 #-}
   rule1907 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_expressionIinfoTree]
   {-# INLINE rule1908 #-}
   rule1908 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule1909 #-}
   rule1909 = \ _constraints ((_expressionIassumptions) :: Assumptions) ((_expressionImatches) :: [Maybe MetaVariableTable]) ((_expressionIuniqueSecondRound) :: Int) ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ((_lhsItryPatterns) :: [(Expression     , [String])]) _localInfo ->
            let infoTuple = metaVarInfo _constraints _expressionIassumptions _localInfo
            in match1 infoTuple _expressionIuniqueSecondRound
                      match_Expression_NegateFloat
                      _lhsItryPatterns _lhsIallPatterns
                      [_expressionImatches]
   {-# INLINE rule1910 #-}
   rule1910 = \ ((_expressionImatchIO) :: IO ()) _ioMatch ->
                                       _expressionImatchIO      >> _ioMatch
   {-# INLINE rule1911 #-}
   rule1911 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule1912 #-}
   rule1912 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule1913 #-}
   rule1913 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Expression_NegateFloat _rangeIself _expressionIself
   {-# INLINE rule1914 #-}
   rule1914 = \ _self ->
     _self
   {-# INLINE rule1915 #-}
   rule1915 = \ _beta ->
     _beta
   {-# INLINE rule1916 #-}
   rule1916 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule1917 #-}
   rule1917 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule1918 #-}
   rule1918 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule1919 #-}
   rule1919 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule1920 #-}
   rule1920 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule1921 #-}
   rule1921 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule1922 #-}
   rule1922 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule1923 #-}
   rule1923 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1924 #-}
   rule1924 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1925 #-}
   rule1925 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1926 #-}
   rule1926 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1927 #-}
   rule1927 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1928 #-}
   rule1928 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1929 #-}
   rule1929 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1930 #-}
   rule1930 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1931 #-}
   rule1931 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1932 #-}
   rule1932 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1933 #-}
   rule1933 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1934 #-}
   rule1934 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1935 #-}
   rule1935 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1936 #-}
   rule1936 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1937 #-}
   rule1937 = \ _parentTree ->
     _parentTree
   {-# INLINE rule1938 #-}
   rule1938 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1939 #-}
   rule1939 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1940 #-}
   rule1940 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1941 #-}
   rule1941 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1942 #-}
   rule1942 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- Expressions -------------------------------------------------
-- wrapper
data Inh_Expressions  = Inh_Expressions { allPatterns_Inh_Expressions :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Expressions :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_Expressions :: (Predicates), betaUnique_Inh_Expressions :: (Int), classEnvironment_Inh_Expressions :: (ClassEnvironment), collectErrors_Inh_Expressions :: (TypeErrors), collectWarnings_Inh_Expressions :: (Warnings), counter_Inh_Expressions :: (Int), currentChunk_Inh_Expressions :: (Int), dictionaryEnvironment_Inh_Expressions :: (DictionaryEnvironment), importEnvironment_Inh_Expressions :: (ImportEnvironment), matchIO_Inh_Expressions :: (IO ()), monos_Inh_Expressions :: (Monos), namesInScope_Inh_Expressions :: (Names), orderedTypeSynonyms_Inh_Expressions :: (OrderedTypeSynonyms), parentTree_Inh_Expressions :: (InfoTree), patternMatchWarnings_Inh_Expressions :: ([Warning]), substitution_Inh_Expressions :: (FixpointSubstitution), tryPatterns_Inh_Expressions :: ([(Expressions    , [String])]), typeschemeMap_Inh_Expressions :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_Expressions :: (Int), uniqueSecondRound_Inh_Expressions :: (Int) }
data Syn_Expressions  = Syn_Expressions { assumptions_Syn_Expressions :: (Assumptions), betaUnique_Syn_Expressions :: (Int), betas_Syn_Expressions :: (Tps), collectErrors_Syn_Expressions :: (TypeErrors), collectInstances_Syn_Expressions :: ([(Name, Instance)]), collectWarnings_Syn_Expressions :: (Warnings), constraintslist_Syn_Expressions :: (ConstraintSets), counter_Syn_Expressions :: (Int), dictionaryEnvironment_Syn_Expressions :: (DictionaryEnvironment), infoTrees_Syn_Expressions :: (InfoTrees), matchIO_Syn_Expressions :: (IO ()), matches_Syn_Expressions :: ([Maybe MetaVariableTable]), patternMatchWarnings_Syn_Expressions :: ([Warning]), self_Syn_Expressions :: (Expressions), unboundNames_Syn_Expressions :: (Names), uniqueChunk_Syn_Expressions :: (Int), uniqueSecondRound_Syn_Expressions :: (Int) }
{-# INLINABLE wrap_Expressions #-}
wrap_Expressions :: T_Expressions  -> Inh_Expressions  -> (Syn_Expressions )
wrap_Expressions (T_Expressions act) (Inh_Expressions _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Expressions_vIn43 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_Expressions_vOut43 _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Expressions_s44 sem arg)
        return (Syn_Expressions _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_Expressions #-}
sem_Expressions :: Expressions  -> T_Expressions 
sem_Expressions list = Prelude.foldr sem_Expressions_Cons sem_Expressions_Nil (Prelude.map sem_Expression list)

-- semantic domain
newtype T_Expressions  = T_Expressions {
                                       attach_T_Expressions :: Identity (T_Expressions_s44 )
                                       }
newtype T_Expressions_s44  = C_Expressions_s44 {
                                               inv_Expressions_s44 :: (T_Expressions_v43 )
                                               }
data T_Expressions_s45  = C_Expressions_s45
type T_Expressions_v43  = (T_Expressions_vIn43 ) -> (T_Expressions_vOut43 )
data T_Expressions_vIn43  = T_Expressions_vIn43 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) ([(Expressions    , [String])]) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_Expressions_vOut43  = T_Expressions_vOut43 (Assumptions) (Int) (Tps) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Maybe MetaVariableTable]) ([Warning]) (Expressions) (Names) (Int) (Int)
{-# NOINLINE sem_Expressions_Cons #-}
sem_Expressions_Cons :: T_Expression  -> T_Expressions  -> T_Expressions 
sem_Expressions_Cons arg_hd_ arg_tl_ = T_Expressions (return st44) where
   {-# NOINLINE st44 #-}
   st44 = let
      v43 :: T_Expressions_v43 
      v43 = \ (T_Expressions_vIn43 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _hdX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_hd_))
         _tlX44 = Control.Monad.Identity.runIdentity (attach_T_Expressions (arg_tl_))
         (T_Expression_vOut40 _hdIassumptions _hdIbeta _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIinfoTree _hdImatchIO _hdImatches _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound) = inv_Expression_s41 _hdX41 (T_Expression_vIn40 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtryPatterns _hdOtypeschemeMap _hdOuniqueChunk _hdOuniqueSecondRound)
         (T_Expressions_vOut43 _tlIassumptions _tlIbetaUnique _tlIbetas _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIinfoTrees _tlImatchIO _tlImatches _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_Expressions_s44 _tlX44 (T_Expressions_vIn43 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtryPatterns _tlOtypeschemeMap _tlOuniqueChunk _tlOuniqueSecondRound)
         _lhsObetas :: Tps
         _lhsObetas = rule1943 _hdIbeta _tlIbetas
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule1944 _hdIassumptions _tlIassumptions
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule1945 _hdIconstraints _tlIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule1946 _hdIinfoTree _tlIinfoTrees
         _lhsOmatches :: [Maybe MetaVariableTable]
         ((_hdOtryPatterns,_tlOtryPatterns),_lhsOmatches,_,_,_,_) = rule1947 _hdImatches _lhsItryPatterns _tlImatches
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule1948 _hdIcollectInstances _tlIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule1949 _hdIunboundNames _tlIunboundNames
         _self = rule1950 _hdIself _tlIself
         _lhsOself :: Expressions
         _lhsOself = rule1951 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule1952 _tlIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule1953 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule1954 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule1955 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule1956 _tlIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule1957 _tlImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule1958 _tlIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule1959 _tlIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule1960 _tlIuniqueSecondRound
         _hdOallPatterns = rule1961 _lhsIallPatterns
         _hdOallTypeSchemes = rule1962 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule1963 _lhsIavailablePredicates
         _hdObetaUnique = rule1964 _lhsIbetaUnique
         _hdOclassEnvironment = rule1965 _lhsIclassEnvironment
         _hdOcollectErrors = rule1966 _lhsIcollectErrors
         _hdOcollectWarnings = rule1967 _lhsIcollectWarnings
         _hdOcounter = rule1968 _lhsIcounter
         _hdOcurrentChunk = rule1969 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule1970 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule1971 _lhsIimportEnvironment
         _hdOmatchIO = rule1972 _lhsImatchIO
         _hdOmonos = rule1973 _lhsImonos
         _hdOnamesInScope = rule1974 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule1975 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule1976 _lhsIparentTree
         _hdOpatternMatchWarnings = rule1977 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule1978 _lhsIsubstitution
         _hdOtypeschemeMap = rule1979 _lhsItypeschemeMap
         _hdOuniqueChunk = rule1980 _lhsIuniqueChunk
         _hdOuniqueSecondRound = rule1981 _lhsIuniqueSecondRound
         _tlOallPatterns = rule1982 _lhsIallPatterns
         _tlOallTypeSchemes = rule1983 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule1984 _lhsIavailablePredicates
         _tlObetaUnique = rule1985 _hdIbetaUnique
         _tlOclassEnvironment = rule1986 _lhsIclassEnvironment
         _tlOcollectErrors = rule1987 _hdIcollectErrors
         _tlOcollectWarnings = rule1988 _hdIcollectWarnings
         _tlOcounter = rule1989 _hdIcounter
         _tlOcurrentChunk = rule1990 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule1991 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule1992 _lhsIimportEnvironment
         _tlOmatchIO = rule1993 _hdImatchIO
         _tlOmonos = rule1994 _lhsImonos
         _tlOnamesInScope = rule1995 _lhsInamesInScope
         _tlOorderedTypeSynonyms = rule1996 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule1997 _lhsIparentTree
         _tlOpatternMatchWarnings = rule1998 _hdIpatternMatchWarnings
         _tlOsubstitution = rule1999 _lhsIsubstitution
         _tlOtypeschemeMap = rule2000 _lhsItypeschemeMap
         _tlOuniqueChunk = rule2001 _hdIuniqueChunk
         _tlOuniqueSecondRound = rule2002 _hdIuniqueSecondRound
         __result_ = T_Expressions_vOut43 _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expressions_s44 v43
   {-# INLINE rule1943 #-}
   rule1943 = \ ((_hdIbeta) :: Tp) ((_tlIbetas) :: Tps) ->
                                _hdIbeta : _tlIbetas
   {-# INLINE rule1944 #-}
   rule1944 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
                                _hdIassumptions `combine` _tlIassumptions
   {-# INLINE rule1945 #-}
   rule1945 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
                                _hdIconstraints : _tlIconstraintslist
   {-# INLINE rule1946 #-}
   rule1946 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTree : _tlIinfoTrees
   {-# INLINE rule1947 #-}
   rule1947 = \ ((_hdImatches) :: [Maybe MetaVariableTable]) ((_lhsItryPatterns) :: [(Expressions    , [String])]) ((_tlImatches) :: [Maybe MetaVariableTable]) ->
            match2' match_Expressions_Cons _lhsItryPatterns [] [_hdImatches, _tlImatches]
   {-# INLINE rule1948 #-}
   rule1948 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule1949 #-}
   rule1949 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule1950 #-}
   rule1950 = \ ((_hdIself) :: Expression) ((_tlIself) :: Expressions) ->
     (:) _hdIself _tlIself
   {-# INLINE rule1951 #-}
   rule1951 = \ _self ->
     _self
   {-# INLINE rule1952 #-}
   rule1952 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule1953 #-}
   rule1953 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule1954 #-}
   rule1954 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule1955 #-}
   rule1955 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule1956 #-}
   rule1956 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule1957 #-}
   rule1957 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule1958 #-}
   rule1958 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule1959 #-}
   rule1959 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule1960 #-}
   rule1960 = \ ((_tlIuniqueSecondRound) :: Int) ->
     _tlIuniqueSecondRound
   {-# INLINE rule1961 #-}
   rule1961 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1962 #-}
   rule1962 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1963 #-}
   rule1963 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1964 #-}
   rule1964 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule1965 #-}
   rule1965 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1966 #-}
   rule1966 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule1967 #-}
   rule1967 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule1968 #-}
   rule1968 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule1969 #-}
   rule1969 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1970 #-}
   rule1970 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule1971 #-}
   rule1971 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1972 #-}
   rule1972 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule1973 #-}
   rule1973 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1974 #-}
   rule1974 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1975 #-}
   rule1975 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1976 #-}
   rule1976 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule1977 #-}
   rule1977 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule1978 #-}
   rule1978 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule1979 #-}
   rule1979 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule1980 #-}
   rule1980 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule1981 #-}
   rule1981 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule1982 #-}
   rule1982 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule1983 #-}
   rule1983 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule1984 #-}
   rule1984 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule1985 #-}
   rule1985 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule1986 #-}
   rule1986 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule1987 #-}
   rule1987 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule1988 #-}
   rule1988 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule1989 #-}
   rule1989 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule1990 #-}
   rule1990 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule1991 #-}
   rule1991 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule1992 #-}
   rule1992 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule1993 #-}
   rule1993 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule1994 #-}
   rule1994 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule1995 #-}
   rule1995 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule1996 #-}
   rule1996 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule1997 #-}
   rule1997 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule1998 #-}
   rule1998 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule1999 #-}
   rule1999 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2000 #-}
   rule2000 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2001 #-}
   rule2001 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
   {-# INLINE rule2002 #-}
   rule2002 = \ ((_hdIuniqueSecondRound) :: Int) ->
     _hdIuniqueSecondRound
{-# NOINLINE sem_Expressions_Nil #-}
sem_Expressions_Nil ::  T_Expressions 
sem_Expressions_Nil  = T_Expressions (return st44) where
   {-# NOINLINE st44 #-}
   st44 = let
      v43 :: T_Expressions_v43 
      v43 = \ (T_Expressions_vIn43 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _lhsObetas :: Tps
         _lhsObetas = rule2003  ()
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2004  ()
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule2005  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2006  ()
         _lhsOmatches :: [Maybe MetaVariableTable]
         ((),_lhsOmatches,_,_,_,_) = rule2007 _lhsItryPatterns
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2008  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2009  ()
         _self = rule2010  ()
         _lhsOself :: Expressions
         _lhsOself = rule2011 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2012 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2013 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2014 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2015 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2016 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2017 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2018 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2019 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule2020 _lhsIuniqueSecondRound
         __result_ = T_Expressions_vOut43 _lhsOassumptions _lhsObetaUnique _lhsObetas _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Expressions_s44 v43
   {-# INLINE rule2003 #-}
   rule2003 = \  (_ :: ()) ->
                                []
   {-# INLINE rule2004 #-}
   rule2004 = \  (_ :: ()) ->
                                noAssumptions
   {-# INLINE rule2005 #-}
   rule2005 = \  (_ :: ()) ->
                                []
   {-# INLINE rule2006 #-}
   rule2006 = \  (_ :: ()) ->
                               []
   {-# INLINE rule2007 #-}
   rule2007 = \ ((_lhsItryPatterns) :: [(Expressions    , [String])]) ->
            match0' match_Expressions_Nil _lhsItryPatterns [] []
   {-# INLINE rule2008 #-}
   rule2008 = \  (_ :: ()) ->
     []
   {-# INLINE rule2009 #-}
   rule2009 = \  (_ :: ()) ->
     []
   {-# INLINE rule2010 #-}
   rule2010 = \  (_ :: ()) ->
     []
   {-# INLINE rule2011 #-}
   rule2011 = \ _self ->
     _self
   {-# INLINE rule2012 #-}
   rule2012 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2013 #-}
   rule2013 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2014 #-}
   rule2014 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2015 #-}
   rule2015 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2016 #-}
   rule2016 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2017 #-}
   rule2017 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2018 #-}
   rule2018 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2019 #-}
   rule2019 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2020 #-}
   rule2020 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- FieldDeclaration --------------------------------------------
-- wrapper
data Inh_FieldDeclaration  = Inh_FieldDeclaration { counter_Inh_FieldDeclaration :: (Int), namesInScope_Inh_FieldDeclaration :: (Names) }
data Syn_FieldDeclaration  = Syn_FieldDeclaration { counter_Syn_FieldDeclaration :: (Int), self_Syn_FieldDeclaration :: (FieldDeclaration), unboundNames_Syn_FieldDeclaration :: (Names) }
{-# INLINABLE wrap_FieldDeclaration #-}
wrap_FieldDeclaration :: T_FieldDeclaration  -> Inh_FieldDeclaration  -> (Syn_FieldDeclaration )
wrap_FieldDeclaration (T_FieldDeclaration act) (Inh_FieldDeclaration _lhsIcounter _lhsInamesInScope) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_FieldDeclaration_vIn46 _lhsIcounter _lhsInamesInScope
        (T_FieldDeclaration_vOut46 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_FieldDeclaration_s47 sem arg)
        return (Syn_FieldDeclaration _lhsOcounter _lhsOself _lhsOunboundNames)
   )

-- cata
{-# INLINE sem_FieldDeclaration #-}
sem_FieldDeclaration :: FieldDeclaration  -> T_FieldDeclaration 
sem_FieldDeclaration ( FieldDeclaration_FieldDeclaration range_ names_ type_ ) = sem_FieldDeclaration_FieldDeclaration ( sem_Range range_ ) ( sem_Names names_ ) ( sem_AnnotatedType type_ )

-- semantic domain
newtype T_FieldDeclaration  = T_FieldDeclaration {
                                                 attach_T_FieldDeclaration :: Identity (T_FieldDeclaration_s47 )
                                                 }
newtype T_FieldDeclaration_s47  = C_FieldDeclaration_s47 {
                                                         inv_FieldDeclaration_s47 :: (T_FieldDeclaration_v46 )
                                                         }
data T_FieldDeclaration_s48  = C_FieldDeclaration_s48
type T_FieldDeclaration_v46  = (T_FieldDeclaration_vIn46 ) -> (T_FieldDeclaration_vOut46 )
data T_FieldDeclaration_vIn46  = T_FieldDeclaration_vIn46 (Int) (Names)
data T_FieldDeclaration_vOut46  = T_FieldDeclaration_vOut46 (Int) (FieldDeclaration) (Names)
{-# NOINLINE sem_FieldDeclaration_FieldDeclaration #-}
sem_FieldDeclaration_FieldDeclaration :: T_Range  -> T_Names  -> T_AnnotatedType  -> T_FieldDeclaration 
sem_FieldDeclaration_FieldDeclaration arg_range_ arg_names_ arg_type_ = T_FieldDeclaration (return st47) where
   {-# NOINLINE st47 #-}
   st47 = let
      v46 :: T_FieldDeclaration_v46 
      v46 = \ (T_FieldDeclaration_vIn46 _lhsIcounter _lhsInamesInScope) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _namesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_names_))
         _typeX8 = Control.Monad.Identity.runIdentity (attach_T_AnnotatedType (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Names_vOut115 _namesIself) = inv_Names_s116 _namesX116 (T_Names_vIn115 )
         (T_AnnotatedType_vOut7 _typeIcounter _typeIself _typeIunboundNames) = inv_AnnotatedType_s8 _typeX8 (T_AnnotatedType_vIn7 _typeOcounter _typeOnamesInScope)
         (_kindErrors,_tyconEnv,_constructorenv,_importEnvironment,_valueConstructors,_allValueConstructors,_typeConstructors,_allTypeConstructors,_warnings) = rule2021  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2022 _typeIunboundNames
         _self = rule2023 _namesIself _rangeIself _typeIself
         _lhsOself :: FieldDeclaration
         _lhsOself = rule2024 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule2025 _typeIcounter
         _typeOcounter = rule2026 _lhsIcounter
         _typeOnamesInScope = rule2027 _lhsInamesInScope
         __result_ = T_FieldDeclaration_vOut46 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_FieldDeclaration_s47 v46
   {-# INLINE rule2021 #-}
   rule2021 = \  (_ :: ()) ->
                                                                                                                                                                              internalError "PartialSyntax.ag" "n/a" "FieldDeclaration.FieldDeclaration"
   {-# INLINE rule2022 #-}
   rule2022 = \ ((_typeIunboundNames) :: Names) ->
     _typeIunboundNames
   {-# INLINE rule2023 #-}
   rule2023 = \ ((_namesIself) :: Names) ((_rangeIself) :: Range) ((_typeIself) :: AnnotatedType) ->
     FieldDeclaration_FieldDeclaration _rangeIself _namesIself _typeIself
   {-# INLINE rule2024 #-}
   rule2024 = \ _self ->
     _self
   {-# INLINE rule2025 #-}
   rule2025 = \ ((_typeIcounter) :: Int) ->
     _typeIcounter
   {-# INLINE rule2026 #-}
   rule2026 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2027 #-}
   rule2027 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope

-- FieldDeclarations -------------------------------------------
-- wrapper
data Inh_FieldDeclarations  = Inh_FieldDeclarations { counter_Inh_FieldDeclarations :: (Int), namesInScope_Inh_FieldDeclarations :: (Names) }
data Syn_FieldDeclarations  = Syn_FieldDeclarations { counter_Syn_FieldDeclarations :: (Int), self_Syn_FieldDeclarations :: (FieldDeclarations), unboundNames_Syn_FieldDeclarations :: (Names) }
{-# INLINABLE wrap_FieldDeclarations #-}
wrap_FieldDeclarations :: T_FieldDeclarations  -> Inh_FieldDeclarations  -> (Syn_FieldDeclarations )
wrap_FieldDeclarations (T_FieldDeclarations act) (Inh_FieldDeclarations _lhsIcounter _lhsInamesInScope) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_FieldDeclarations_vIn49 _lhsIcounter _lhsInamesInScope
        (T_FieldDeclarations_vOut49 _lhsOcounter _lhsOself _lhsOunboundNames) <- return (inv_FieldDeclarations_s50 sem arg)
        return (Syn_FieldDeclarations _lhsOcounter _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_FieldDeclarations #-}
sem_FieldDeclarations :: FieldDeclarations  -> T_FieldDeclarations 
sem_FieldDeclarations list = Prelude.foldr sem_FieldDeclarations_Cons sem_FieldDeclarations_Nil (Prelude.map sem_FieldDeclaration list)

-- semantic domain
newtype T_FieldDeclarations  = T_FieldDeclarations {
                                                   attach_T_FieldDeclarations :: Identity (T_FieldDeclarations_s50 )
                                                   }
newtype T_FieldDeclarations_s50  = C_FieldDeclarations_s50 {
                                                           inv_FieldDeclarations_s50 :: (T_FieldDeclarations_v49 )
                                                           }
data T_FieldDeclarations_s51  = C_FieldDeclarations_s51
type T_FieldDeclarations_v49  = (T_FieldDeclarations_vIn49 ) -> (T_FieldDeclarations_vOut49 )
data T_FieldDeclarations_vIn49  = T_FieldDeclarations_vIn49 (Int) (Names)
data T_FieldDeclarations_vOut49  = T_FieldDeclarations_vOut49 (Int) (FieldDeclarations) (Names)
{-# NOINLINE sem_FieldDeclarations_Cons #-}
sem_FieldDeclarations_Cons :: T_FieldDeclaration  -> T_FieldDeclarations  -> T_FieldDeclarations 
sem_FieldDeclarations_Cons arg_hd_ arg_tl_ = T_FieldDeclarations (return st50) where
   {-# NOINLINE st50 #-}
   st50 = let
      v49 :: T_FieldDeclarations_v49 
      v49 = \ (T_FieldDeclarations_vIn49 _lhsIcounter _lhsInamesInScope) -> ( let
         _hdX47 = Control.Monad.Identity.runIdentity (attach_T_FieldDeclaration (arg_hd_))
         _tlX50 = Control.Monad.Identity.runIdentity (attach_T_FieldDeclarations (arg_tl_))
         (T_FieldDeclaration_vOut46 _hdIcounter _hdIself _hdIunboundNames) = inv_FieldDeclaration_s47 _hdX47 (T_FieldDeclaration_vIn46 _hdOcounter _hdOnamesInScope)
         (T_FieldDeclarations_vOut49 _tlIcounter _tlIself _tlIunboundNames) = inv_FieldDeclarations_s50 _tlX50 (T_FieldDeclarations_vIn49 _tlOcounter _tlOnamesInScope)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2028 _hdIunboundNames _tlIunboundNames
         _self = rule2029 _hdIself _tlIself
         _lhsOself :: FieldDeclarations
         _lhsOself = rule2030 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule2031 _tlIcounter
         _hdOcounter = rule2032 _lhsIcounter
         _hdOnamesInScope = rule2033 _lhsInamesInScope
         _tlOcounter = rule2034 _hdIcounter
         _tlOnamesInScope = rule2035 _lhsInamesInScope
         __result_ = T_FieldDeclarations_vOut49 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_FieldDeclarations_s50 v49
   {-# INLINE rule2028 #-}
   rule2028 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule2029 #-}
   rule2029 = \ ((_hdIself) :: FieldDeclaration) ((_tlIself) :: FieldDeclarations) ->
     (:) _hdIself _tlIself
   {-# INLINE rule2030 #-}
   rule2030 = \ _self ->
     _self
   {-# INLINE rule2031 #-}
   rule2031 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule2032 #-}
   rule2032 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2033 #-}
   rule2033 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2034 #-}
   rule2034 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule2035 #-}
   rule2035 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
{-# NOINLINE sem_FieldDeclarations_Nil #-}
sem_FieldDeclarations_Nil ::  T_FieldDeclarations 
sem_FieldDeclarations_Nil  = T_FieldDeclarations (return st50) where
   {-# NOINLINE st50 #-}
   st50 = let
      v49 :: T_FieldDeclarations_v49 
      v49 = \ (T_FieldDeclarations_vIn49 _lhsIcounter _lhsInamesInScope) -> ( let
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2036  ()
         _self = rule2037  ()
         _lhsOself :: FieldDeclarations
         _lhsOself = rule2038 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule2039 _lhsIcounter
         __result_ = T_FieldDeclarations_vOut49 _lhsOcounter _lhsOself _lhsOunboundNames
         in __result_ )
     in C_FieldDeclarations_s50 v49
   {-# INLINE rule2036 #-}
   rule2036 = \  (_ :: ()) ->
     []
   {-# INLINE rule2037 #-}
   rule2037 = \  (_ :: ()) ->
     []
   {-# INLINE rule2038 #-}
   rule2038 = \ _self ->
     _self
   {-# INLINE rule2039 #-}
   rule2039 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter

-- Fixity ------------------------------------------------------
-- wrapper
data Inh_Fixity  = Inh_Fixity {  }
data Syn_Fixity  = Syn_Fixity { self_Syn_Fixity :: (Fixity) }
{-# INLINABLE wrap_Fixity #-}
wrap_Fixity :: T_Fixity  -> Inh_Fixity  -> (Syn_Fixity )
wrap_Fixity (T_Fixity act) (Inh_Fixity ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Fixity_vIn52 
        (T_Fixity_vOut52 _lhsOself) <- return (inv_Fixity_s53 sem arg)
        return (Syn_Fixity _lhsOself)
   )

-- cata
{-# NOINLINE sem_Fixity #-}
sem_Fixity :: Fixity  -> T_Fixity 
sem_Fixity ( Fixity_Infixl range_ ) = sem_Fixity_Infixl ( sem_Range range_ )
sem_Fixity ( Fixity_Infixr range_ ) = sem_Fixity_Infixr ( sem_Range range_ )
sem_Fixity ( Fixity_Infix range_ ) = sem_Fixity_Infix ( sem_Range range_ )

-- semantic domain
newtype T_Fixity  = T_Fixity {
                             attach_T_Fixity :: Identity (T_Fixity_s53 )
                             }
newtype T_Fixity_s53  = C_Fixity_s53 {
                                     inv_Fixity_s53 :: (T_Fixity_v52 )
                                     }
data T_Fixity_s54  = C_Fixity_s54
type T_Fixity_v52  = (T_Fixity_vIn52 ) -> (T_Fixity_vOut52 )
data T_Fixity_vIn52  = T_Fixity_vIn52 
data T_Fixity_vOut52  = T_Fixity_vOut52 (Fixity)
{-# NOINLINE sem_Fixity_Infixl #-}
sem_Fixity_Infixl :: T_Range  -> T_Fixity 
sem_Fixity_Infixl arg_range_ = T_Fixity (return st53) where
   {-# NOINLINE st53 #-}
   st53 = let
      v52 :: T_Fixity_v52 
      v52 = \ (T_Fixity_vIn52 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _self = rule2040 _rangeIself
         _lhsOself :: Fixity
         _lhsOself = rule2041 _self
         __result_ = T_Fixity_vOut52 _lhsOself
         in __result_ )
     in C_Fixity_s53 v52
   {-# INLINE rule2040 #-}
   rule2040 = \ ((_rangeIself) :: Range) ->
     Fixity_Infixl _rangeIself
   {-# INLINE rule2041 #-}
   rule2041 = \ _self ->
     _self
{-# NOINLINE sem_Fixity_Infixr #-}
sem_Fixity_Infixr :: T_Range  -> T_Fixity 
sem_Fixity_Infixr arg_range_ = T_Fixity (return st53) where
   {-# NOINLINE st53 #-}
   st53 = let
      v52 :: T_Fixity_v52 
      v52 = \ (T_Fixity_vIn52 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _self = rule2042 _rangeIself
         _lhsOself :: Fixity
         _lhsOself = rule2043 _self
         __result_ = T_Fixity_vOut52 _lhsOself
         in __result_ )
     in C_Fixity_s53 v52
   {-# INLINE rule2042 #-}
   rule2042 = \ ((_rangeIself) :: Range) ->
     Fixity_Infixr _rangeIself
   {-# INLINE rule2043 #-}
   rule2043 = \ _self ->
     _self
{-# NOINLINE sem_Fixity_Infix #-}
sem_Fixity_Infix :: T_Range  -> T_Fixity 
sem_Fixity_Infix arg_range_ = T_Fixity (return st53) where
   {-# NOINLINE st53 #-}
   st53 = let
      v52 :: T_Fixity_v52 
      v52 = \ (T_Fixity_vIn52 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _self = rule2044 _rangeIself
         _lhsOself :: Fixity
         _lhsOself = rule2045 _self
         __result_ = T_Fixity_vOut52 _lhsOself
         in __result_ )
     in C_Fixity_s53 v52
   {-# INLINE rule2044 #-}
   rule2044 = \ ((_rangeIself) :: Range) ->
     Fixity_Infix _rangeIself
   {-# INLINE rule2045 #-}
   rule2045 = \ _self ->
     _self

-- FunctionBinding ---------------------------------------------
-- wrapper
data Inh_FunctionBinding  = Inh_FunctionBinding { allPatterns_Inh_FunctionBinding :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_FunctionBinding :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_FunctionBinding :: (Predicates), betaRight_Inh_FunctionBinding :: (Tp), betaUnique_Inh_FunctionBinding :: (Int), betasLeft_Inh_FunctionBinding :: (Tps), classEnvironment_Inh_FunctionBinding :: (ClassEnvironment), collectErrors_Inh_FunctionBinding :: (TypeErrors), collectWarnings_Inh_FunctionBinding :: (Warnings), counter_Inh_FunctionBinding :: (Int), currentChunk_Inh_FunctionBinding :: (Int), dictionaryEnvironment_Inh_FunctionBinding :: (DictionaryEnvironment), importEnvironment_Inh_FunctionBinding :: (ImportEnvironment), matchIO_Inh_FunctionBinding :: (IO ()), monos_Inh_FunctionBinding :: (Monos), namesInScope_Inh_FunctionBinding :: (Names), orderedTypeSynonyms_Inh_FunctionBinding :: (OrderedTypeSynonyms), parentTree_Inh_FunctionBinding :: (InfoTree), patternMatchWarnings_Inh_FunctionBinding :: ([Warning]), substitution_Inh_FunctionBinding :: (FixpointSubstitution), typeschemeMap_Inh_FunctionBinding :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_FunctionBinding :: (Int) }
data Syn_FunctionBinding  = Syn_FunctionBinding { argcount_Syn_FunctionBinding :: (Int), assumptions_Syn_FunctionBinding :: (Assumptions), betaUnique_Syn_FunctionBinding :: (Int), collectErrors_Syn_FunctionBinding :: (TypeErrors), collectInstances_Syn_FunctionBinding :: ([(Name, Instance)]), collectWarnings_Syn_FunctionBinding :: (Warnings), constraints_Syn_FunctionBinding :: (ConstraintSet), counter_Syn_FunctionBinding :: (Int), dictionaryEnvironment_Syn_FunctionBinding :: (DictionaryEnvironment), elements_Syn_FunctionBinding :: ( ([PatternElement], Bool) ), infoTree_Syn_FunctionBinding :: (InfoTree), matchIO_Syn_FunctionBinding :: (IO ()), name_Syn_FunctionBinding :: (Name), numberOfPatterns_Syn_FunctionBinding :: (Int), patternMatchWarnings_Syn_FunctionBinding :: ([Warning]), self_Syn_FunctionBinding :: (FunctionBinding), unboundNames_Syn_FunctionBinding :: (Names), uniqueChunk_Syn_FunctionBinding :: (Int), unrwar_Syn_FunctionBinding :: (Warning) }
{-# INLINABLE wrap_FunctionBinding #-}
wrap_FunctionBinding :: T_FunctionBinding  -> Inh_FunctionBinding  -> (Syn_FunctionBinding )
wrap_FunctionBinding (T_FunctionBinding act) (Inh_FunctionBinding _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar) <- return (inv_FunctionBinding_s56 sem arg)
        return (Syn_FunctionBinding _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar)
   )

-- cata
{-# NOINLINE sem_FunctionBinding #-}
sem_FunctionBinding :: FunctionBinding  -> T_FunctionBinding 
sem_FunctionBinding ( FunctionBinding_Hole range_ id_ ) = sem_FunctionBinding_Hole ( sem_Range range_ ) id_
sem_FunctionBinding ( FunctionBinding_Feedback range_ feedback_ functionBinding_ ) = sem_FunctionBinding_Feedback ( sem_Range range_ ) feedback_ ( sem_FunctionBinding functionBinding_ )
sem_FunctionBinding ( FunctionBinding_FunctionBinding range_ lefthandside_ righthandside_ ) = sem_FunctionBinding_FunctionBinding ( sem_Range range_ ) ( sem_LeftHandSide lefthandside_ ) ( sem_RightHandSide righthandside_ )

-- semantic domain
newtype T_FunctionBinding  = T_FunctionBinding {
                                               attach_T_FunctionBinding :: Identity (T_FunctionBinding_s56 )
                                               }
newtype T_FunctionBinding_s56  = C_FunctionBinding_s56 {
                                                       inv_FunctionBinding_s56 :: (T_FunctionBinding_v55 )
                                                       }
data T_FunctionBinding_s57  = C_FunctionBinding_s57
type T_FunctionBinding_v55  = (T_FunctionBinding_vIn55 ) -> (T_FunctionBinding_vOut55 )
data T_FunctionBinding_vIn55  = T_FunctionBinding_vIn55 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (Tps) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_FunctionBinding_vOut55  = T_FunctionBinding_vOut55 (Int) (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) ( ([PatternElement], Bool) ) (InfoTree) (IO ()) (Name) (Int) ([Warning]) (FunctionBinding) (Names) (Int) (Warning)
{-# NOINLINE sem_FunctionBinding_Hole #-}
sem_FunctionBinding_Hole :: T_Range  -> (Integer) -> T_FunctionBinding 
sem_FunctionBinding_Hole arg_range_ arg_id_ = T_FunctionBinding (return st56) where
   {-# NOINLINE st56 #-}
   st56 = let
      v55 :: T_FunctionBinding_v55 
      v55 = \ (T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _assumptions = rule2046  ()
         _constraints = rule2047  ()
         _numberOfPatterns = rule2048  ()
         _name = rule2049  ()
         _localInfo = rule2050 _lhsImonos _self
         _parentTree = rule2051 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2052 _parentTree
         _lhsOargcount :: Int
         _lhsOargcount = rule2053  ()
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule2054  ()
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule2055  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2056  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2057  ()
         _self = rule2058 _rangeIself arg_id_
         _lhsOself :: FunctionBinding
         _lhsOself = rule2059 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2060 _assumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2061 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2062 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2063 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2064 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2065 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2066 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2067 _lhsImatchIO
         _lhsOname :: Name
         _lhsOname = rule2068 _name
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2069 _numberOfPatterns
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2070 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2071 _lhsIuniqueChunk
         __result_ = T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_FunctionBinding_s56 v55
   {-# INLINE rule2046 #-}
   rule2046 = \  (_ :: ()) ->
                                 noAssumptions
   {-# INLINE rule2047 #-}
   rule2047 = \  (_ :: ()) ->
                                 emptyTree
   {-# INLINE rule2048 #-}
   rule2048 = \  (_ :: ()) ->
                                 0
   {-# INLINE rule2049 #-}
   rule2049 = \  (_ :: ()) ->
                                 internalError "TypeInferencing.ag" "n/a" "FunctionBindings(2)"
   {-# INLINE rule2050 #-}
   rule2050 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_FB _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2051 #-}
   rule2051 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                                          node _lhsIparentTree _localInfo []
   {-# INLINE rule2052 #-}
   rule2052 = \ _parentTree ->
                                          _parentTree
   {-# INLINE rule2053 #-}
   rule2053 = \  (_ :: ()) ->
                                         0
   {-# INLINE rule2054 #-}
   rule2054 = \  (_ :: ()) ->
                                         ([], False)
   {-# INLINE rule2055 #-}
   rule2055 = \  (_ :: ()) ->
                                         pmError "FunctionBinding_Hole.unrwar" "hole unrwar"
   {-# INLINE rule2056 #-}
   rule2056 = \  (_ :: ()) ->
     []
   {-# INLINE rule2057 #-}
   rule2057 = \  (_ :: ()) ->
     []
   {-# INLINE rule2058 #-}
   rule2058 = \ ((_rangeIself) :: Range) id_ ->
     FunctionBinding_Hole _rangeIself id_
   {-# INLINE rule2059 #-}
   rule2059 = \ _self ->
     _self
   {-# INLINE rule2060 #-}
   rule2060 = \ _assumptions ->
     _assumptions
   {-# INLINE rule2061 #-}
   rule2061 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2062 #-}
   rule2062 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2063 #-}
   rule2063 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2064 #-}
   rule2064 = \ _constraints ->
     _constraints
   {-# INLINE rule2065 #-}
   rule2065 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2066 #-}
   rule2066 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2067 #-}
   rule2067 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2068 #-}
   rule2068 = \ _name ->
     _name
   {-# INLINE rule2069 #-}
   rule2069 = \ _numberOfPatterns ->
     _numberOfPatterns
   {-# INLINE rule2070 #-}
   rule2070 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2071 #-}
   rule2071 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_FunctionBinding_Feedback #-}
sem_FunctionBinding_Feedback :: T_Range  -> (String) -> T_FunctionBinding  -> T_FunctionBinding 
sem_FunctionBinding_Feedback arg_range_ arg_feedback_ arg_functionBinding_ = T_FunctionBinding (return st56) where
   {-# NOINLINE st56 #-}
   st56 = let
      v55 :: T_FunctionBinding_v55 
      v55 = \ (T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _functionBindingX56 = Control.Monad.Identity.runIdentity (attach_T_FunctionBinding (arg_functionBinding_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_FunctionBinding_vOut55 _functionBindingIargcount _functionBindingIassumptions _functionBindingIbetaUnique _functionBindingIcollectErrors _functionBindingIcollectInstances _functionBindingIcollectWarnings _functionBindingIconstraints _functionBindingIcounter _functionBindingIdictionaryEnvironment _functionBindingIelements _functionBindingIinfoTree _functionBindingImatchIO _functionBindingIname _functionBindingInumberOfPatterns _functionBindingIpatternMatchWarnings _functionBindingIself _functionBindingIunboundNames _functionBindingIuniqueChunk _functionBindingIunrwar) = inv_FunctionBinding_s56 _functionBindingX56 (T_FunctionBinding_vIn55 _functionBindingOallPatterns _functionBindingOallTypeSchemes _functionBindingOavailablePredicates _functionBindingObetaRight _functionBindingObetaUnique _functionBindingObetasLeft _functionBindingOclassEnvironment _functionBindingOcollectErrors _functionBindingOcollectWarnings _functionBindingOcounter _functionBindingOcurrentChunk _functionBindingOdictionaryEnvironment _functionBindingOimportEnvironment _functionBindingOmatchIO _functionBindingOmonos _functionBindingOnamesInScope _functionBindingOorderedTypeSynonyms _functionBindingOparentTree _functionBindingOpatternMatchWarnings _functionBindingOsubstitution _functionBindingOtypeschemeMap _functionBindingOuniqueChunk)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2072 _functionBindingIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2073 _functionBindingIunboundNames
         _self = rule2074 _functionBindingIself _rangeIself arg_feedback_
         _lhsOself :: FunctionBinding
         _lhsOself = rule2075 _self
         _lhsOargcount :: Int
         _lhsOargcount = rule2076 _functionBindingIargcount
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2077 _functionBindingIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2078 _functionBindingIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2079 _functionBindingIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2080 _functionBindingIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2081 _functionBindingIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2082 _functionBindingIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2083 _functionBindingIdictionaryEnvironment
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule2084 _functionBindingIelements
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2085 _functionBindingIinfoTree
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2086 _functionBindingImatchIO
         _lhsOname :: Name
         _lhsOname = rule2087 _functionBindingIname
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2088 _functionBindingInumberOfPatterns
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2089 _functionBindingIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2090 _functionBindingIuniqueChunk
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule2091 _functionBindingIunrwar
         _functionBindingOallPatterns = rule2092 _lhsIallPatterns
         _functionBindingOallTypeSchemes = rule2093 _lhsIallTypeSchemes
         _functionBindingOavailablePredicates = rule2094 _lhsIavailablePredicates
         _functionBindingObetaRight = rule2095 _lhsIbetaRight
         _functionBindingObetaUnique = rule2096 _lhsIbetaUnique
         _functionBindingObetasLeft = rule2097 _lhsIbetasLeft
         _functionBindingOclassEnvironment = rule2098 _lhsIclassEnvironment
         _functionBindingOcollectErrors = rule2099 _lhsIcollectErrors
         _functionBindingOcollectWarnings = rule2100 _lhsIcollectWarnings
         _functionBindingOcounter = rule2101 _lhsIcounter
         _functionBindingOcurrentChunk = rule2102 _lhsIcurrentChunk
         _functionBindingOdictionaryEnvironment = rule2103 _lhsIdictionaryEnvironment
         _functionBindingOimportEnvironment = rule2104 _lhsIimportEnvironment
         _functionBindingOmatchIO = rule2105 _lhsImatchIO
         _functionBindingOmonos = rule2106 _lhsImonos
         _functionBindingOnamesInScope = rule2107 _lhsInamesInScope
         _functionBindingOorderedTypeSynonyms = rule2108 _lhsIorderedTypeSynonyms
         _functionBindingOparentTree = rule2109 _lhsIparentTree
         _functionBindingOpatternMatchWarnings = rule2110 _lhsIpatternMatchWarnings
         _functionBindingOsubstitution = rule2111 _lhsIsubstitution
         _functionBindingOtypeschemeMap = rule2112 _lhsItypeschemeMap
         _functionBindingOuniqueChunk = rule2113 _lhsIuniqueChunk
         __result_ = T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_FunctionBinding_s56 v55
   {-# INLINE rule2072 #-}
   rule2072 = \ ((_functionBindingIcollectInstances) :: [(Name, Instance)]) ->
     _functionBindingIcollectInstances
   {-# INLINE rule2073 #-}
   rule2073 = \ ((_functionBindingIunboundNames) :: Names) ->
     _functionBindingIunboundNames
   {-# INLINE rule2074 #-}
   rule2074 = \ ((_functionBindingIself) :: FunctionBinding) ((_rangeIself) :: Range) feedback_ ->
     FunctionBinding_Feedback _rangeIself feedback_ _functionBindingIself
   {-# INLINE rule2075 #-}
   rule2075 = \ _self ->
     _self
   {-# INLINE rule2076 #-}
   rule2076 = \ ((_functionBindingIargcount) :: Int) ->
     _functionBindingIargcount
   {-# INLINE rule2077 #-}
   rule2077 = \ ((_functionBindingIassumptions) :: Assumptions) ->
     _functionBindingIassumptions
   {-# INLINE rule2078 #-}
   rule2078 = \ ((_functionBindingIbetaUnique) :: Int) ->
     _functionBindingIbetaUnique
   {-# INLINE rule2079 #-}
   rule2079 = \ ((_functionBindingIcollectErrors) :: TypeErrors) ->
     _functionBindingIcollectErrors
   {-# INLINE rule2080 #-}
   rule2080 = \ ((_functionBindingIcollectWarnings) :: Warnings) ->
     _functionBindingIcollectWarnings
   {-# INLINE rule2081 #-}
   rule2081 = \ ((_functionBindingIconstraints) :: ConstraintSet) ->
     _functionBindingIconstraints
   {-# INLINE rule2082 #-}
   rule2082 = \ ((_functionBindingIcounter) :: Int) ->
     _functionBindingIcounter
   {-# INLINE rule2083 #-}
   rule2083 = \ ((_functionBindingIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _functionBindingIdictionaryEnvironment
   {-# INLINE rule2084 #-}
   rule2084 = \ ((_functionBindingIelements) ::  ([PatternElement], Bool) ) ->
     _functionBindingIelements
   {-# INLINE rule2085 #-}
   rule2085 = \ ((_functionBindingIinfoTree) :: InfoTree) ->
     _functionBindingIinfoTree
   {-# INLINE rule2086 #-}
   rule2086 = \ ((_functionBindingImatchIO) :: IO ()) ->
     _functionBindingImatchIO
   {-# INLINE rule2087 #-}
   rule2087 = \ ((_functionBindingIname) :: Name) ->
     _functionBindingIname
   {-# INLINE rule2088 #-}
   rule2088 = \ ((_functionBindingInumberOfPatterns) :: Int) ->
     _functionBindingInumberOfPatterns
   {-# INLINE rule2089 #-}
   rule2089 = \ ((_functionBindingIpatternMatchWarnings) :: [Warning]) ->
     _functionBindingIpatternMatchWarnings
   {-# INLINE rule2090 #-}
   rule2090 = \ ((_functionBindingIuniqueChunk) :: Int) ->
     _functionBindingIuniqueChunk
   {-# INLINE rule2091 #-}
   rule2091 = \ ((_functionBindingIunrwar) :: Warning) ->
     _functionBindingIunrwar
   {-# INLINE rule2092 #-}
   rule2092 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2093 #-}
   rule2093 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2094 #-}
   rule2094 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2095 #-}
   rule2095 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule2096 #-}
   rule2096 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2097 #-}
   rule2097 = \ ((_lhsIbetasLeft) :: Tps) ->
     _lhsIbetasLeft
   {-# INLINE rule2098 #-}
   rule2098 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2099 #-}
   rule2099 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2100 #-}
   rule2100 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2101 #-}
   rule2101 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2102 #-}
   rule2102 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2103 #-}
   rule2103 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2104 #-}
   rule2104 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2105 #-}
   rule2105 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2106 #-}
   rule2106 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2107 #-}
   rule2107 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2108 #-}
   rule2108 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2109 #-}
   rule2109 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2110 #-}
   rule2110 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2111 #-}
   rule2111 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2112 #-}
   rule2112 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2113 #-}
   rule2113 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_FunctionBinding_FunctionBinding #-}
sem_FunctionBinding_FunctionBinding :: T_Range  -> T_LeftHandSide  -> T_RightHandSide  -> T_FunctionBinding 
sem_FunctionBinding_FunctionBinding arg_range_ arg_lefthandside_ arg_righthandside_ = T_FunctionBinding (return st56) where
   {-# NOINLINE st56 #-}
   st56 = let
      v55 :: T_FunctionBinding_v55 
      v55 = \ (T_FunctionBinding_vIn55 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _lefthandsideX83 = Control.Monad.Identity.runIdentity (attach_T_LeftHandSide (arg_lefthandside_))
         _righthandsideX149 = Control.Monad.Identity.runIdentity (attach_T_RightHandSide (arg_righthandside_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_LeftHandSide_vOut82 _lefthandsideIargcount _lefthandsideIbetaUnique _lefthandsideIbetas _lefthandsideIconstraints _lefthandsideIcounter _lefthandsideIelements _lefthandsideIenvironment _lefthandsideIinfoTrees _lefthandsideIname _lefthandsideInumberOfPatterns _lefthandsideIpatVarNames _lefthandsideIpatternMatchWarnings _lefthandsideIself _lefthandsideIunboundNames) = inv_LeftHandSide_s83 _lefthandsideX83 (T_LeftHandSide_vIn82 _lefthandsideObetaUnique _lefthandsideOcounter _lefthandsideOimportEnvironment _lefthandsideOmonos _lefthandsideOnamesInScope _lefthandsideOparentTree _lefthandsideOpatternMatchWarnings)
         (T_RightHandSide_vOut148 _righthandsideIassumptions _righthandsideIbetaUnique _righthandsideIcollectErrors _righthandsideIcollectInstances _righthandsideIcollectWarnings _righthandsideIconstraints _righthandsideIcounter _righthandsideIdictionaryEnvironment _righthandsideIfallthrough _righthandsideIinfoTree _righthandsideImatchIO _righthandsideIpatternMatchWarnings _righthandsideIself _righthandsideIunboundNames _righthandsideIuniqueChunk) = inv_RightHandSide_s149 _righthandsideX149 (T_RightHandSide_vIn148 _righthandsideOallPatterns _righthandsideOallTypeSchemes _righthandsideOavailablePredicates _righthandsideObetaRight _righthandsideObetaUnique _righthandsideOclassEnvironment _righthandsideOcollectErrors _righthandsideOcollectWarnings _righthandsideOcounter _righthandsideOcurrentChunk _righthandsideOdictionaryEnvironment _righthandsideOimportEnvironment _righthandsideOmatchIO _righthandsideOmonos _righthandsideOnamesInScope _righthandsideOorderedTypeSynonyms _righthandsideOparentTree _righthandsideOpatternMatchWarnings _righthandsideOsubstitution _righthandsideOtypeschemeMap _righthandsideOuniqueChunk)
         _righthandsideOmonos = rule2114 _csetBinds _lefthandsideIenvironment _lhsImonos
         _constraints = rule2115 _conLeft _csetBinds _lefthandsideIconstraints _righthandsideIconstraints
         _conLeft = rule2116 _cinfoLeft _lefthandsideIbetas _lhsIbetasLeft
         _lhsOassumptions :: Assumptions
         (_csetBinds,_lhsOassumptions) = rule2117 _cinfoBind _lefthandsideIenvironment _righthandsideIassumptions
         _cinfoLeft = rule2118 _lhsIbetasLeft _lhsIparentTree _parentTree
         _cinfoBind = rule2119 _lefthandsideIenvironment _parentTree
         _localInfo = rule2120 _lhsImonos _self
         _parentTree = rule2121 _lefthandsideIinfoTrees _lhsIparentTree _localInfo _righthandsideIinfoTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2122 _parentTree
         (_namesInScope,_unboundNames,_scopeInfo) = rule2123 _lefthandsideIpatVarNames _lhsInamesInScope _righthandsideIunboundNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2124 _unboundNames
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule2125 _lefthandsideIself
         _lhsOelements ::  ([PatternElement], Bool) 
         _lhsOelements = rule2126 _lefthandsideIelements _righthandsideIfallthrough
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2127 _righthandsideIcollectInstances
         _self = rule2128 _lefthandsideIself _rangeIself _righthandsideIself
         _lhsOself :: FunctionBinding
         _lhsOself = rule2129 _self
         _lhsOargcount :: Int
         _lhsOargcount = rule2130 _lefthandsideIargcount
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2131 _righthandsideIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2132 _righthandsideIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2133 _righthandsideIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2134 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2135 _righthandsideIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2136 _righthandsideIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2137 _righthandsideImatchIO
         _lhsOname :: Name
         _lhsOname = rule2138 _lefthandsideIname
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2139 _lefthandsideInumberOfPatterns
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2140 _righthandsideIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2141 _righthandsideIuniqueChunk
         _lefthandsideObetaUnique = rule2142 _lhsIbetaUnique
         _lefthandsideOcounter = rule2143 _lhsIcounter
         _lefthandsideOimportEnvironment = rule2144 _lhsIimportEnvironment
         _lefthandsideOmonos = rule2145 _lhsImonos
         _lefthandsideOnamesInScope = rule2146 _namesInScope
         _lefthandsideOparentTree = rule2147 _parentTree
         _lefthandsideOpatternMatchWarnings = rule2148 _lhsIpatternMatchWarnings
         _righthandsideOallPatterns = rule2149 _lhsIallPatterns
         _righthandsideOallTypeSchemes = rule2150 _lhsIallTypeSchemes
         _righthandsideOavailablePredicates = rule2151 _lhsIavailablePredicates
         _righthandsideObetaRight = rule2152 _lhsIbetaRight
         _righthandsideObetaUnique = rule2153 _lefthandsideIbetaUnique
         _righthandsideOclassEnvironment = rule2154 _lhsIclassEnvironment
         _righthandsideOcollectErrors = rule2155 _lhsIcollectErrors
         _righthandsideOcollectWarnings = rule2156 _lhsIcollectWarnings
         _righthandsideOcounter = rule2157 _lefthandsideIcounter
         _righthandsideOcurrentChunk = rule2158 _lhsIcurrentChunk
         _righthandsideOdictionaryEnvironment = rule2159 _lhsIdictionaryEnvironment
         _righthandsideOimportEnvironment = rule2160 _lhsIimportEnvironment
         _righthandsideOmatchIO = rule2161 _lhsImatchIO
         _righthandsideOnamesInScope = rule2162 _namesInScope
         _righthandsideOorderedTypeSynonyms = rule2163 _lhsIorderedTypeSynonyms
         _righthandsideOparentTree = rule2164 _parentTree
         _righthandsideOpatternMatchWarnings = rule2165 _lefthandsideIpatternMatchWarnings
         _righthandsideOsubstitution = rule2166 _lhsIsubstitution
         _righthandsideOtypeschemeMap = rule2167 _lhsItypeschemeMap
         _righthandsideOuniqueChunk = rule2168 _lhsIuniqueChunk
         __result_ = T_FunctionBinding_vOut55 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOelements _lhsOinfoTree _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwar
         in __result_ )
     in C_FunctionBinding_s56 v55
   {-# INLINE rule2114 #-}
   rule2114 = \ _csetBinds ((_lefthandsideIenvironment) :: PatternAssumptions) ((_lhsImonos) :: Monos) ->
                                      M.elems _lefthandsideIenvironment ++ getMonos _csetBinds ++ _lhsImonos
   {-# INLINE rule2115 #-}
   rule2115 = \ _conLeft _csetBinds ((_lefthandsideIconstraints) :: ConstraintSet) ((_righthandsideIconstraints) :: ConstraintSet) ->
                                      _csetBinds .>>.
                                      Node [ _conLeft  .<. _lefthandsideIconstraints
                                           , _righthandsideIconstraints
                                           ]
   {-# INLINE rule2116 #-}
   rule2116 = \ _cinfoLeft ((_lefthandsideIbetas) :: Tps) ((_lhsIbetasLeft) :: Tps) ->
                                      zipWith3 (\t1 t2 nr -> (t1 .==. t2) (_cinfoLeft nr)) _lefthandsideIbetas _lhsIbetasLeft [0..]
   {-# INLINE rule2117 #-}
   rule2117 = \ _cinfoBind ((_lefthandsideIenvironment) :: PatternAssumptions) ((_righthandsideIassumptions) :: Assumptions) ->
                                          (_lefthandsideIenvironment .===. _righthandsideIassumptions) _cinfoBind
   {-# INLINE rule2118 #-}
   rule2118 = \ ((_lhsIbetasLeft) :: Tps) ((_lhsIparentTree) :: InfoTree) _parentTree ->
     \num  ->
     orphanConstraint num "pattern of function binding" _parentTree
        [ Unifier (head (ftv (_lhsIbetasLeft !! num))) (ordinal True (num+1)++" pattern of function bindings", attribute _lhsIparentTree, "pattern") ]
   {-# INLINE rule2119 #-}
   rule2119 = \ ((_lefthandsideIenvironment) :: PatternAssumptions) _parentTree ->
     \name -> variableConstraint "variable" (nameToUHA_Expr name)
        [ FolkloreConstraint
        , makeUnifier name "function binding" _lefthandsideIenvironment _parentTree
        ]
   {-# INLINE rule2120 #-}
   rule2120 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_FB _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2121 #-}
   rule2121 = \ ((_lefthandsideIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ((_righthandsideIinfoTree) :: InfoTree) ->
                                          node _lhsIparentTree _localInfo (_lefthandsideIinfoTrees ++ [_righthandsideIinfoTree])
   {-# INLINE rule2122 #-}
   rule2122 = \ _parentTree ->
                                          _parentTree
   {-# INLINE rule2123 #-}
   rule2123 = \ ((_lefthandsideIpatVarNames) :: Names) ((_lhsInamesInScope) :: Names) ((_righthandsideIunboundNames) :: Names) ->
                                                                        changeOfScope _lefthandsideIpatVarNames _righthandsideIunboundNames _lhsInamesInScope
   {-# INLINE rule2124 #-}
   rule2124 = \ _unboundNames ->
                                             _unboundNames
   {-# INLINE rule2125 #-}
   rule2125 = \ ((_lefthandsideIself) :: LeftHandSide) ->
                                         UnreachablePatternLHS _lefthandsideIself
   {-# INLINE rule2126 #-}
   rule2126 = \ ((_lefthandsideIelements) ::   [PatternElement]        ) ((_righthandsideIfallthrough) :: Bool) ->
                                         (_lefthandsideIelements, _righthandsideIfallthrough)
   {-# INLINE rule2127 #-}
   rule2127 = \ ((_righthandsideIcollectInstances) :: [(Name, Instance)]) ->
     _righthandsideIcollectInstances
   {-# INLINE rule2128 #-}
   rule2128 = \ ((_lefthandsideIself) :: LeftHandSide) ((_rangeIself) :: Range) ((_righthandsideIself) :: RightHandSide) ->
     FunctionBinding_FunctionBinding _rangeIself _lefthandsideIself _righthandsideIself
   {-# INLINE rule2129 #-}
   rule2129 = \ _self ->
     _self
   {-# INLINE rule2130 #-}
   rule2130 = \ ((_lefthandsideIargcount) :: Int) ->
     _lefthandsideIargcount
   {-# INLINE rule2131 #-}
   rule2131 = \ ((_righthandsideIbetaUnique) :: Int) ->
     _righthandsideIbetaUnique
   {-# INLINE rule2132 #-}
   rule2132 = \ ((_righthandsideIcollectErrors) :: TypeErrors) ->
     _righthandsideIcollectErrors
   {-# INLINE rule2133 #-}
   rule2133 = \ ((_righthandsideIcollectWarnings) :: Warnings) ->
     _righthandsideIcollectWarnings
   {-# INLINE rule2134 #-}
   rule2134 = \ _constraints ->
     _constraints
   {-# INLINE rule2135 #-}
   rule2135 = \ ((_righthandsideIcounter) :: Int) ->
     _righthandsideIcounter
   {-# INLINE rule2136 #-}
   rule2136 = \ ((_righthandsideIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _righthandsideIdictionaryEnvironment
   {-# INLINE rule2137 #-}
   rule2137 = \ ((_righthandsideImatchIO) :: IO ()) ->
     _righthandsideImatchIO
   {-# INLINE rule2138 #-}
   rule2138 = \ ((_lefthandsideIname) :: Name) ->
     _lefthandsideIname
   {-# INLINE rule2139 #-}
   rule2139 = \ ((_lefthandsideInumberOfPatterns) :: Int) ->
     _lefthandsideInumberOfPatterns
   {-# INLINE rule2140 #-}
   rule2140 = \ ((_righthandsideIpatternMatchWarnings) :: [Warning]) ->
     _righthandsideIpatternMatchWarnings
   {-# INLINE rule2141 #-}
   rule2141 = \ ((_righthandsideIuniqueChunk) :: Int) ->
     _righthandsideIuniqueChunk
   {-# INLINE rule2142 #-}
   rule2142 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2143 #-}
   rule2143 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2144 #-}
   rule2144 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2145 #-}
   rule2145 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2146 #-}
   rule2146 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule2147 #-}
   rule2147 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2148 #-}
   rule2148 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2149 #-}
   rule2149 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2150 #-}
   rule2150 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2151 #-}
   rule2151 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2152 #-}
   rule2152 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule2153 #-}
   rule2153 = \ ((_lefthandsideIbetaUnique) :: Int) ->
     _lefthandsideIbetaUnique
   {-# INLINE rule2154 #-}
   rule2154 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2155 #-}
   rule2155 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2156 #-}
   rule2156 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2157 #-}
   rule2157 = \ ((_lefthandsideIcounter) :: Int) ->
     _lefthandsideIcounter
   {-# INLINE rule2158 #-}
   rule2158 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2159 #-}
   rule2159 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2160 #-}
   rule2160 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2161 #-}
   rule2161 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2162 #-}
   rule2162 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule2163 #-}
   rule2163 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2164 #-}
   rule2164 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2165 #-}
   rule2165 = \ ((_lefthandsideIpatternMatchWarnings) :: [Warning]) ->
     _lefthandsideIpatternMatchWarnings
   {-# INLINE rule2166 #-}
   rule2166 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2167 #-}
   rule2167 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2168 #-}
   rule2168 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- FunctionBindings --------------------------------------------
-- wrapper
data Inh_FunctionBindings  = Inh_FunctionBindings { allPatterns_Inh_FunctionBindings :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_FunctionBindings :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_FunctionBindings :: (Predicates), betaRight_Inh_FunctionBindings :: (Tp), betaUnique_Inh_FunctionBindings :: (Int), betasLeft_Inh_FunctionBindings :: (Tps), classEnvironment_Inh_FunctionBindings :: (ClassEnvironment), collectErrors_Inh_FunctionBindings :: (TypeErrors), collectWarnings_Inh_FunctionBindings :: (Warnings), counter_Inh_FunctionBindings :: (Int), currentChunk_Inh_FunctionBindings :: (Int), dictionaryEnvironment_Inh_FunctionBindings :: (DictionaryEnvironment), importEnvironment_Inh_FunctionBindings :: (ImportEnvironment), matchIO_Inh_FunctionBindings :: (IO ()), monos_Inh_FunctionBindings :: (Monos), namesInScope_Inh_FunctionBindings :: (Names), orderedTypeSynonyms_Inh_FunctionBindings :: (OrderedTypeSynonyms), parentTree_Inh_FunctionBindings :: (InfoTree), patternMatchWarnings_Inh_FunctionBindings :: ([Warning]), substitution_Inh_FunctionBindings :: (FixpointSubstitution), typeschemeMap_Inh_FunctionBindings :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_FunctionBindings :: (Int) }
data Syn_FunctionBindings  = Syn_FunctionBindings { argcount_Syn_FunctionBindings :: (Int), assumptions_Syn_FunctionBindings :: (Assumptions), betaUnique_Syn_FunctionBindings :: (Int), collectErrors_Syn_FunctionBindings :: (TypeErrors), collectInstances_Syn_FunctionBindings :: ([(Name, Instance)]), collectWarnings_Syn_FunctionBindings :: (Warnings), constraintslist_Syn_FunctionBindings :: (ConstraintSets), counter_Syn_FunctionBindings :: (Int), dictionaryEnvironment_Syn_FunctionBindings :: (DictionaryEnvironment), elementss_Syn_FunctionBindings :: ([([PatternElement], Bool)]), infoTrees_Syn_FunctionBindings :: (InfoTrees), matchIO_Syn_FunctionBindings :: (IO ()), name_Syn_FunctionBindings :: (Name), numberOfPatterns_Syn_FunctionBindings :: (Int), patternMatchWarnings_Syn_FunctionBindings :: ([Warning]), self_Syn_FunctionBindings :: (FunctionBindings), unboundNames_Syn_FunctionBindings :: (Names), uniqueChunk_Syn_FunctionBindings :: (Int), unrwars_Syn_FunctionBindings :: ([Warning]) }
{-# INLINABLE wrap_FunctionBindings #-}
wrap_FunctionBindings :: T_FunctionBindings  -> Inh_FunctionBindings  -> (Syn_FunctionBindings )
wrap_FunctionBindings (T_FunctionBindings act) (Inh_FunctionBindings _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_FunctionBindings_vIn58 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_FunctionBindings_vOut58 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars) <- return (inv_FunctionBindings_s59 sem arg)
        return (Syn_FunctionBindings _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars)
   )

-- cata
{-# NOINLINE sem_FunctionBindings #-}
sem_FunctionBindings :: FunctionBindings  -> T_FunctionBindings 
sem_FunctionBindings list = Prelude.foldr sem_FunctionBindings_Cons sem_FunctionBindings_Nil (Prelude.map sem_FunctionBinding list)

-- semantic domain
newtype T_FunctionBindings  = T_FunctionBindings {
                                                 attach_T_FunctionBindings :: Identity (T_FunctionBindings_s59 )
                                                 }
newtype T_FunctionBindings_s59  = C_FunctionBindings_s59 {
                                                         inv_FunctionBindings_s59 :: (T_FunctionBindings_v58 )
                                                         }
data T_FunctionBindings_s60  = C_FunctionBindings_s60
type T_FunctionBindings_v58  = (T_FunctionBindings_vIn58 ) -> (T_FunctionBindings_vOut58 )
data T_FunctionBindings_vIn58  = T_FunctionBindings_vIn58 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (Tps) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_FunctionBindings_vOut58  = T_FunctionBindings_vOut58 (Int) (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) ([([PatternElement], Bool)]) (InfoTrees) (IO ()) (Name) (Int) ([Warning]) (FunctionBindings) (Names) (Int) ([Warning])
{-# NOINLINE sem_FunctionBindings_Cons #-}
sem_FunctionBindings_Cons :: T_FunctionBinding  -> T_FunctionBindings  -> T_FunctionBindings 
sem_FunctionBindings_Cons arg_hd_ arg_tl_ = T_FunctionBindings (return st59) where
   {-# NOINLINE st59 #-}
   st59 = let
      v58 :: T_FunctionBindings_v58 
      v58 = \ (T_FunctionBindings_vIn58 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _hdX56 = Control.Monad.Identity.runIdentity (attach_T_FunctionBinding (arg_hd_))
         _tlX59 = Control.Monad.Identity.runIdentity (attach_T_FunctionBindings (arg_tl_))
         (T_FunctionBinding_vOut55 _hdIargcount _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIelements _hdIinfoTree _hdImatchIO _hdIname _hdInumberOfPatterns _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIunrwar) = inv_FunctionBinding_s56 _hdX56 (T_FunctionBinding_vIn55 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaRight _hdObetaUnique _hdObetasLeft _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk)
         (T_FunctionBindings_vOut58 _tlIargcount _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIelementss _tlIinfoTrees _tlImatchIO _tlIname _tlInumberOfPatterns _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIunrwars) = inv_FunctionBindings_s59 _tlX59 (T_FunctionBindings_vIn58 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaRight _tlObetaUnique _tlObetasLeft _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2169 _hdIassumptions _tlIassumptions
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2170 _hdInumberOfPatterns
         _lhsOname :: Name
         _lhsOname = rule2171 _hdIname
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule2172 _hdIconstraints _tlIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2173 _hdIinfoTree _tlIinfoTrees
         _lhsOelementss :: [([PatternElement], Bool)]
         _lhsOelementss = rule2174 _hdIelements _tlIelementss
         _lhsOunrwars :: [Warning]
         _lhsOunrwars = rule2175 _hdIunrwar _tlIunrwars
         _lhsOargcount :: Int
         _lhsOargcount = rule2176 _hdIargcount
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2177 _hdIcollectInstances _tlIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2178 _hdIunboundNames _tlIunboundNames
         _self = rule2179 _hdIself _tlIself
         _lhsOself :: FunctionBindings
         _lhsOself = rule2180 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2181 _tlIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2182 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2183 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2184 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2185 _tlIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2186 _tlImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2187 _tlIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2188 _tlIuniqueChunk
         _hdOallPatterns = rule2189 _lhsIallPatterns
         _hdOallTypeSchemes = rule2190 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule2191 _lhsIavailablePredicates
         _hdObetaRight = rule2192 _lhsIbetaRight
         _hdObetaUnique = rule2193 _lhsIbetaUnique
         _hdObetasLeft = rule2194 _lhsIbetasLeft
         _hdOclassEnvironment = rule2195 _lhsIclassEnvironment
         _hdOcollectErrors = rule2196 _lhsIcollectErrors
         _hdOcollectWarnings = rule2197 _lhsIcollectWarnings
         _hdOcounter = rule2198 _lhsIcounter
         _hdOcurrentChunk = rule2199 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule2200 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule2201 _lhsIimportEnvironment
         _hdOmatchIO = rule2202 _lhsImatchIO
         _hdOmonos = rule2203 _lhsImonos
         _hdOnamesInScope = rule2204 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule2205 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule2206 _lhsIparentTree
         _hdOpatternMatchWarnings = rule2207 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule2208 _lhsIsubstitution
         _hdOtypeschemeMap = rule2209 _lhsItypeschemeMap
         _hdOuniqueChunk = rule2210 _lhsIuniqueChunk
         _tlOallPatterns = rule2211 _lhsIallPatterns
         _tlOallTypeSchemes = rule2212 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule2213 _lhsIavailablePredicates
         _tlObetaRight = rule2214 _lhsIbetaRight
         _tlObetaUnique = rule2215 _hdIbetaUnique
         _tlObetasLeft = rule2216 _lhsIbetasLeft
         _tlOclassEnvironment = rule2217 _lhsIclassEnvironment
         _tlOcollectErrors = rule2218 _hdIcollectErrors
         _tlOcollectWarnings = rule2219 _hdIcollectWarnings
         _tlOcounter = rule2220 _hdIcounter
         _tlOcurrentChunk = rule2221 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule2222 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule2223 _lhsIimportEnvironment
         _tlOmatchIO = rule2224 _hdImatchIO
         _tlOmonos = rule2225 _lhsImonos
         _tlOnamesInScope = rule2226 _lhsInamesInScope
         _tlOorderedTypeSynonyms = rule2227 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule2228 _lhsIparentTree
         _tlOpatternMatchWarnings = rule2229 _hdIpatternMatchWarnings
         _tlOsubstitution = rule2230 _lhsIsubstitution
         _tlOtypeschemeMap = rule2231 _lhsItypeschemeMap
         _tlOuniqueChunk = rule2232 _hdIuniqueChunk
         __result_ = T_FunctionBindings_vOut58 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
         in __result_ )
     in C_FunctionBindings_s59 v58
   {-# INLINE rule2169 #-}
   rule2169 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
                                 _hdIassumptions `combine` _tlIassumptions
   {-# INLINE rule2170 #-}
   rule2170 = \ ((_hdInumberOfPatterns) :: Int) ->
                                 _hdInumberOfPatterns
   {-# INLINE rule2171 #-}
   rule2171 = \ ((_hdIname) :: Name) ->
                                 _hdIname
   {-# INLINE rule2172 #-}
   rule2172 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
                                 _hdIconstraints : _tlIconstraintslist
   {-# INLINE rule2173 #-}
   rule2173 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTree : _tlIinfoTrees
   {-# INLINE rule2174 #-}
   rule2174 = \ ((_hdIelements) ::  ([PatternElement], Bool) ) ((_tlIelementss) :: [([PatternElement], Bool)]) ->
                                         _hdIelements : _tlIelementss
   {-# INLINE rule2175 #-}
   rule2175 = \ ((_hdIunrwar) :: Warning) ((_tlIunrwars) :: [Warning]) ->
                                         _hdIunrwar   : _tlIunrwars
   {-# INLINE rule2176 #-}
   rule2176 = \ ((_hdIargcount) :: Int) ->
                                         _hdIargcount
   {-# INLINE rule2177 #-}
   rule2177 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule2178 #-}
   rule2178 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule2179 #-}
   rule2179 = \ ((_hdIself) :: FunctionBinding) ((_tlIself) :: FunctionBindings) ->
     (:) _hdIself _tlIself
   {-# INLINE rule2180 #-}
   rule2180 = \ _self ->
     _self
   {-# INLINE rule2181 #-}
   rule2181 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule2182 #-}
   rule2182 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule2183 #-}
   rule2183 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule2184 #-}
   rule2184 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule2185 #-}
   rule2185 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule2186 #-}
   rule2186 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule2187 #-}
   rule2187 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule2188 #-}
   rule2188 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule2189 #-}
   rule2189 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2190 #-}
   rule2190 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2191 #-}
   rule2191 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2192 #-}
   rule2192 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule2193 #-}
   rule2193 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2194 #-}
   rule2194 = \ ((_lhsIbetasLeft) :: Tps) ->
     _lhsIbetasLeft
   {-# INLINE rule2195 #-}
   rule2195 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2196 #-}
   rule2196 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2197 #-}
   rule2197 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2198 #-}
   rule2198 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2199 #-}
   rule2199 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2200 #-}
   rule2200 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2201 #-}
   rule2201 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2202 #-}
   rule2202 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2203 #-}
   rule2203 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2204 #-}
   rule2204 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2205 #-}
   rule2205 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2206 #-}
   rule2206 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2207 #-}
   rule2207 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2208 #-}
   rule2208 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2209 #-}
   rule2209 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2210 #-}
   rule2210 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2211 #-}
   rule2211 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2212 #-}
   rule2212 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2213 #-}
   rule2213 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2214 #-}
   rule2214 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule2215 #-}
   rule2215 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule2216 #-}
   rule2216 = \ ((_lhsIbetasLeft) :: Tps) ->
     _lhsIbetasLeft
   {-# INLINE rule2217 #-}
   rule2217 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2218 #-}
   rule2218 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule2219 #-}
   rule2219 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule2220 #-}
   rule2220 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule2221 #-}
   rule2221 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2222 #-}
   rule2222 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule2223 #-}
   rule2223 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2224 #-}
   rule2224 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule2225 #-}
   rule2225 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2226 #-}
   rule2226 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2227 #-}
   rule2227 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2228 #-}
   rule2228 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2229 #-}
   rule2229 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule2230 #-}
   rule2230 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2231 #-}
   rule2231 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2232 #-}
   rule2232 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
{-# NOINLINE sem_FunctionBindings_Nil #-}
sem_FunctionBindings_Nil ::  T_FunctionBindings 
sem_FunctionBindings_Nil  = T_FunctionBindings (return st59) where
   {-# NOINLINE st59 #-}
   st59 = let
      v58 :: T_FunctionBindings_v58 
      v58 = \ (T_FunctionBindings_vIn58 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIbetasLeft _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2233  ()
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2234  ()
         _lhsOname :: Name
         _lhsOname = rule2235  ()
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule2236  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2237  ()
         _lhsOelementss :: [([PatternElement], Bool)]
         _lhsOelementss = rule2238  ()
         _lhsOunrwars :: [Warning]
         _lhsOunrwars = rule2239  ()
         _lhsOargcount :: Int
         _lhsOargcount = rule2240  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2241  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2242  ()
         _self = rule2243  ()
         _lhsOself :: FunctionBindings
         _lhsOself = rule2244 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2245 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2246 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2247 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2248 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2249 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2250 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2251 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2252 _lhsIuniqueChunk
         __result_ = T_FunctionBindings_vOut58 _lhsOargcount _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOelementss _lhsOinfoTrees _lhsOmatchIO _lhsOname _lhsOnumberOfPatterns _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOunrwars
         in __result_ )
     in C_FunctionBindings_s59 v58
   {-# INLINE rule2233 #-}
   rule2233 = \  (_ :: ()) ->
                                 noAssumptions
   {-# INLINE rule2234 #-}
   rule2234 = \  (_ :: ()) ->
                                 internalError "TypeInferencing.ag" "n/a" "FunctionBindings(1)"
   {-# INLINE rule2235 #-}
   rule2235 = \  (_ :: ()) ->
                                 internalError "TypeInferencing.ag" "n/a" "FunctionBindings(2)"
   {-# INLINE rule2236 #-}
   rule2236 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule2237 #-}
   rule2237 = \  (_ :: ()) ->
                               []
   {-# INLINE rule2238 #-}
   rule2238 = \  (_ :: ()) ->
                                         []
   {-# INLINE rule2239 #-}
   rule2239 = \  (_ :: ()) ->
                                         []
   {-# INLINE rule2240 #-}
   rule2240 = \  (_ :: ()) ->
                                         pmError "FunctionBindings_Nil.argcount" "?empty list of function bindings?"
   {-# INLINE rule2241 #-}
   rule2241 = \  (_ :: ()) ->
     []
   {-# INLINE rule2242 #-}
   rule2242 = \  (_ :: ()) ->
     []
   {-# INLINE rule2243 #-}
   rule2243 = \  (_ :: ()) ->
     []
   {-# INLINE rule2244 #-}
   rule2244 = \ _self ->
     _self
   {-# INLINE rule2245 #-}
   rule2245 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2246 #-}
   rule2246 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2247 #-}
   rule2247 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2248 #-}
   rule2248 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2249 #-}
   rule2249 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2250 #-}
   rule2250 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2251 #-}
   rule2251 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2252 #-}
   rule2252 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- GuardedExpression -------------------------------------------
-- wrapper
data Inh_GuardedExpression  = Inh_GuardedExpression { allPatterns_Inh_GuardedExpression :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_GuardedExpression :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_GuardedExpression :: (Predicates), betaRight_Inh_GuardedExpression :: (Tp), betaUnique_Inh_GuardedExpression :: (Int), classEnvironment_Inh_GuardedExpression :: (ClassEnvironment), collectErrors_Inh_GuardedExpression :: (TypeErrors), collectWarnings_Inh_GuardedExpression :: (Warnings), counter_Inh_GuardedExpression :: (Int), currentChunk_Inh_GuardedExpression :: (Int), dictionaryEnvironment_Inh_GuardedExpression :: (DictionaryEnvironment), importEnvironment_Inh_GuardedExpression :: (ImportEnvironment), matchIO_Inh_GuardedExpression :: (IO ()), monos_Inh_GuardedExpression :: (Monos), namesInScope_Inh_GuardedExpression :: (Names), numberOfGuards_Inh_GuardedExpression :: (Int), orderedTypeSynonyms_Inh_GuardedExpression :: (OrderedTypeSynonyms), parentTree_Inh_GuardedExpression :: (InfoTree), patternMatchWarnings_Inh_GuardedExpression :: ([Warning]), substitution_Inh_GuardedExpression :: (FixpointSubstitution), typeschemeMap_Inh_GuardedExpression :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_GuardedExpression :: (Int), uniqueSecondRound_Inh_GuardedExpression :: (Int) }
data Syn_GuardedExpression  = Syn_GuardedExpression { assumptions_Syn_GuardedExpression :: (Assumptions), betaUnique_Syn_GuardedExpression :: (Int), collectErrors_Syn_GuardedExpression :: (TypeErrors), collectInstances_Syn_GuardedExpression :: ([(Name, Instance)]), collectWarnings_Syn_GuardedExpression :: (Warnings), constraints_Syn_GuardedExpression :: (ConstraintSet), counter_Syn_GuardedExpression :: (Int), dictionaryEnvironment_Syn_GuardedExpression :: (DictionaryEnvironment), fallthrough_Syn_GuardedExpression :: (Bool), infoTrees_Syn_GuardedExpression :: (InfoTrees), matchIO_Syn_GuardedExpression :: (IO ()), patternMatchWarnings_Syn_GuardedExpression :: ([Warning]), range_Syn_GuardedExpression :: (Range), self_Syn_GuardedExpression :: (GuardedExpression), unboundNames_Syn_GuardedExpression :: (Names), uniqueChunk_Syn_GuardedExpression :: (Int), uniqueSecondRound_Syn_GuardedExpression :: (Int), unrwar_Syn_GuardedExpression :: (Warning) }
{-# INLINABLE wrap_GuardedExpression #-}
wrap_GuardedExpression :: T_GuardedExpression  -> Inh_GuardedExpression  -> (Syn_GuardedExpression )
wrap_GuardedExpression (T_GuardedExpression act) (Inh_GuardedExpression _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_GuardedExpression_vIn61 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_GuardedExpression_vOut61 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrange _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound _lhsOunrwar) <- return (inv_GuardedExpression_s62 sem arg)
        return (Syn_GuardedExpression _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrange _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound _lhsOunrwar)
   )

-- cata
{-# NOINLINE sem_GuardedExpression #-}
sem_GuardedExpression :: GuardedExpression  -> T_GuardedExpression 
sem_GuardedExpression ( GuardedExpression_GuardedExpression range_ guard_ expression_ ) = sem_GuardedExpression_GuardedExpression ( sem_Range range_ ) ( sem_Expression guard_ ) ( sem_Expression expression_ )

-- semantic domain
newtype T_GuardedExpression  = T_GuardedExpression {
                                                   attach_T_GuardedExpression :: Identity (T_GuardedExpression_s62 )
                                                   }
newtype T_GuardedExpression_s62  = C_GuardedExpression_s62 {
                                                           inv_GuardedExpression_s62 :: (T_GuardedExpression_v61 )
                                                           }
data T_GuardedExpression_s63  = C_GuardedExpression_s63
type T_GuardedExpression_v61  = (T_GuardedExpression_vIn61 ) -> (T_GuardedExpression_vOut61 )
data T_GuardedExpression_vIn61  = T_GuardedExpression_vIn61 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (Int) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_GuardedExpression_vOut61  = T_GuardedExpression_vOut61 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Bool) (InfoTrees) (IO ()) ([Warning]) (Range) (GuardedExpression) (Names) (Int) (Int) (Warning)
{-# NOINLINE sem_GuardedExpression_GuardedExpression #-}
sem_GuardedExpression_GuardedExpression :: T_Range  -> T_Expression  -> T_Expression  -> T_GuardedExpression 
sem_GuardedExpression_GuardedExpression arg_range_ arg_guard_ arg_expression_ = T_GuardedExpression (return st62) where
   {-# NOINLINE st62 #-}
   st62 = let
      v61 :: T_GuardedExpression_v61 
      v61 = \ (T_GuardedExpression_vIn61 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _guardX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_guard_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _guardIassumptions _guardIbeta _guardIbetaUnique _guardIcollectErrors _guardIcollectInstances _guardIcollectWarnings _guardIconstraints _guardIcounter _guardIdictionaryEnvironment _guardIinfoTree _guardImatchIO _guardImatches _guardIpatternMatchWarnings _guardIself _guardIunboundNames _guardIuniqueChunk _guardIuniqueSecondRound) = inv_Expression_s41 _guardX41 (T_Expression_vIn40 _guardOallPatterns _guardOallTypeSchemes _guardOavailablePredicates _guardObetaUnique _guardOclassEnvironment _guardOcollectErrors _guardOcollectWarnings _guardOcounter _guardOcurrentChunk _guardOdictionaryEnvironment _guardOimportEnvironment _guardOmatchIO _guardOmonos _guardOnamesInScope _guardOorderedTypeSynonyms _guardOparentTree _guardOpatternMatchWarnings _guardOsubstitution _guardOtryPatterns _guardOtypeschemeMap _guardOuniqueChunk _guardOuniqueSecondRound)
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2253 _expressionIconstraints _guardIconstraints _newconExpr _newconGuard
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2254 _expressionIassumptions _guardIassumptions
         _newconGuard = rule2255 _cinfoGuard _guardIbeta
         _newconExpr = rule2256 _cinfoExpr _expressionIbeta _lhsIbetaRight
         _cinfoGuard = rule2257 _guardIinfoTree
         _cinfoExpr = rule2258 _expressionIinfoTree _lhsIbetaRight _lhsInumberOfGuards _lhsIparentTree
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2259 _expressionIinfoTree _guardIinfoTree
         _guardOtryPatterns = rule2260  ()
         _expressionOtryPatterns = rule2261  ()
         _lhsOfallthrough :: Bool
         _lhsOfallthrough = rule2262 _guardIself
         _lhsOunrwar :: Warning
         _lhsOunrwar = rule2263 _guardIself _rangeIself
         _lhsOrange :: Range
         _lhsOrange = rule2264 _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2265 _expressionIcollectInstances _guardIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2266 _expressionIunboundNames _guardIunboundNames
         _self = rule2267 _expressionIself _guardIself _rangeIself
         _lhsOself :: GuardedExpression
         _lhsOself = rule2268 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2269 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2270 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2271 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2272 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2273 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2274 _expressionImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2275 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2276 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule2277 _expressionIuniqueSecondRound
         _guardOallPatterns = rule2278 _lhsIallPatterns
         _guardOallTypeSchemes = rule2279 _lhsIallTypeSchemes
         _guardOavailablePredicates = rule2280 _lhsIavailablePredicates
         _guardObetaUnique = rule2281 _lhsIbetaUnique
         _guardOclassEnvironment = rule2282 _lhsIclassEnvironment
         _guardOcollectErrors = rule2283 _lhsIcollectErrors
         _guardOcollectWarnings = rule2284 _lhsIcollectWarnings
         _guardOcounter = rule2285 _lhsIcounter
         _guardOcurrentChunk = rule2286 _lhsIcurrentChunk
         _guardOdictionaryEnvironment = rule2287 _lhsIdictionaryEnvironment
         _guardOimportEnvironment = rule2288 _lhsIimportEnvironment
         _guardOmatchIO = rule2289 _lhsImatchIO
         _guardOmonos = rule2290 _lhsImonos
         _guardOnamesInScope = rule2291 _lhsInamesInScope
         _guardOorderedTypeSynonyms = rule2292 _lhsIorderedTypeSynonyms
         _guardOparentTree = rule2293 _lhsIparentTree
         _guardOpatternMatchWarnings = rule2294 _lhsIpatternMatchWarnings
         _guardOsubstitution = rule2295 _lhsIsubstitution
         _guardOtypeschemeMap = rule2296 _lhsItypeschemeMap
         _guardOuniqueChunk = rule2297 _lhsIuniqueChunk
         _guardOuniqueSecondRound = rule2298 _lhsIuniqueSecondRound
         _expressionOallPatterns = rule2299 _lhsIallPatterns
         _expressionOallTypeSchemes = rule2300 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule2301 _lhsIavailablePredicates
         _expressionObetaUnique = rule2302 _guardIbetaUnique
         _expressionOclassEnvironment = rule2303 _lhsIclassEnvironment
         _expressionOcollectErrors = rule2304 _guardIcollectErrors
         _expressionOcollectWarnings = rule2305 _guardIcollectWarnings
         _expressionOcounter = rule2306 _guardIcounter
         _expressionOcurrentChunk = rule2307 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule2308 _guardIdictionaryEnvironment
         _expressionOimportEnvironment = rule2309 _lhsIimportEnvironment
         _expressionOmatchIO = rule2310 _guardImatchIO
         _expressionOmonos = rule2311 _lhsImonos
         _expressionOnamesInScope = rule2312 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule2313 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule2314 _lhsIparentTree
         _expressionOpatternMatchWarnings = rule2315 _guardIpatternMatchWarnings
         _expressionOsubstitution = rule2316 _lhsIsubstitution
         _expressionOtypeschemeMap = rule2317 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule2318 _guardIuniqueChunk
         _expressionOuniqueSecondRound = rule2319 _guardIuniqueSecondRound
         __result_ = T_GuardedExpression_vOut61 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOrange _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound _lhsOunrwar
         in __result_ )
     in C_GuardedExpression_s62 v61
   {-# INLINE rule2253 #-}
   rule2253 = \ ((_expressionIconstraints) :: ConstraintSet) ((_guardIconstraints) :: ConstraintSet) _newconExpr _newconGuard ->
                            Node [ _newconGuard .<. _guardIconstraints
                                 , _newconExpr  .<. _expressionIconstraints
                                 ]
   {-# INLINE rule2254 #-}
   rule2254 = \ ((_expressionIassumptions) :: Assumptions) ((_guardIassumptions) :: Assumptions) ->
                            _guardIassumptions `combine` _expressionIassumptions
   {-# INLINE rule2255 #-}
   rule2255 = \ _cinfoGuard ((_guardIbeta) :: Tp) ->
                            [ (_guardIbeta .==. boolType) _cinfoGuard ]
   {-# INLINE rule2256 #-}
   rule2256 = \ _cinfoExpr ((_expressionIbeta) :: Tp) ((_lhsIbetaRight) :: Tp) ->
                            [ (_expressionIbeta .==. _lhsIbetaRight) _cinfoExpr ]
   {-# INLINE rule2257 #-}
   rule2257 = \ ((_guardIinfoTree) :: InfoTree) ->
     resultConstraint "guard" _guardIinfoTree
        []
   {-# INLINE rule2258 #-}
   rule2258 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIbetaRight) :: Tp) ((_lhsInumberOfGuards) :: Int) ((_lhsIparentTree) :: InfoTree) ->
     resultConstraint "guarded expression" _expressionIinfoTree $
        [ HasTrustFactor 10.0 | _lhsInumberOfGuards < 2 ] ++
        [ Unifier (head (ftv _lhsIbetaRight)) ("right-hand sides", attribute (skip_UHA_FB_RHS _lhsIparentTree), "right-hand side") ]
   {-# INLINE rule2259 #-}
   rule2259 = \ ((_expressionIinfoTree) :: InfoTree) ((_guardIinfoTree) :: InfoTree) ->
                                            [_guardIinfoTree, _expressionIinfoTree]
   {-# INLINE rule2260 #-}
   rule2260 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule2261 #-}
   rule2261 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule2262 #-}
   rule2262 = \ ((_guardIself) :: Expression) ->
                                            case _guardIself
                                            of Expression_Variable    _ (Name_Identifier _ _ "otherwise") -> False
                                               Expression_Constructor _ (Name_Identifier _ _ "True"     ) -> False
                                               _                                                          -> True
   {-# INLINE rule2263 #-}
   rule2263 = \ ((_guardIself) :: Expression) ((_rangeIself) :: Range) ->
                                       UnreachableGuard _rangeIself _guardIself
   {-# INLINE rule2264 #-}
   rule2264 = \ ((_rangeIself) :: Range) ->
                                      _rangeIself
   {-# INLINE rule2265 #-}
   rule2265 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_guardIcollectInstances) :: [(Name, Instance)]) ->
     _guardIcollectInstances  ++  _expressionIcollectInstances
   {-# INLINE rule2266 #-}
   rule2266 = \ ((_expressionIunboundNames) :: Names) ((_guardIunboundNames) :: Names) ->
     _guardIunboundNames ++ _expressionIunboundNames
   {-# INLINE rule2267 #-}
   rule2267 = \ ((_expressionIself) :: Expression) ((_guardIself) :: Expression) ((_rangeIself) :: Range) ->
     GuardedExpression_GuardedExpression _rangeIself _guardIself _expressionIself
   {-# INLINE rule2268 #-}
   rule2268 = \ _self ->
     _self
   {-# INLINE rule2269 #-}
   rule2269 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule2270 #-}
   rule2270 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule2271 #-}
   rule2271 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule2272 #-}
   rule2272 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule2273 #-}
   rule2273 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule2274 #-}
   rule2274 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule2275 #-}
   rule2275 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule2276 #-}
   rule2276 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule2277 #-}
   rule2277 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule2278 #-}
   rule2278 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2279 #-}
   rule2279 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2280 #-}
   rule2280 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2281 #-}
   rule2281 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2282 #-}
   rule2282 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2283 #-}
   rule2283 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2284 #-}
   rule2284 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2285 #-}
   rule2285 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2286 #-}
   rule2286 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2287 #-}
   rule2287 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2288 #-}
   rule2288 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2289 #-}
   rule2289 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2290 #-}
   rule2290 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2291 #-}
   rule2291 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2292 #-}
   rule2292 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2293 #-}
   rule2293 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2294 #-}
   rule2294 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2295 #-}
   rule2295 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2296 #-}
   rule2296 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2297 #-}
   rule2297 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2298 #-}
   rule2298 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule2299 #-}
   rule2299 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2300 #-}
   rule2300 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2301 #-}
   rule2301 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2302 #-}
   rule2302 = \ ((_guardIbetaUnique) :: Int) ->
     _guardIbetaUnique
   {-# INLINE rule2303 #-}
   rule2303 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2304 #-}
   rule2304 = \ ((_guardIcollectErrors) :: TypeErrors) ->
     _guardIcollectErrors
   {-# INLINE rule2305 #-}
   rule2305 = \ ((_guardIcollectWarnings) :: Warnings) ->
     _guardIcollectWarnings
   {-# INLINE rule2306 #-}
   rule2306 = \ ((_guardIcounter) :: Int) ->
     _guardIcounter
   {-# INLINE rule2307 #-}
   rule2307 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2308 #-}
   rule2308 = \ ((_guardIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _guardIdictionaryEnvironment
   {-# INLINE rule2309 #-}
   rule2309 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2310 #-}
   rule2310 = \ ((_guardImatchIO) :: IO ()) ->
     _guardImatchIO
   {-# INLINE rule2311 #-}
   rule2311 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2312 #-}
   rule2312 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2313 #-}
   rule2313 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2314 #-}
   rule2314 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2315 #-}
   rule2315 = \ ((_guardIpatternMatchWarnings) :: [Warning]) ->
     _guardIpatternMatchWarnings
   {-# INLINE rule2316 #-}
   rule2316 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2317 #-}
   rule2317 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2318 #-}
   rule2318 = \ ((_guardIuniqueChunk) :: Int) ->
     _guardIuniqueChunk
   {-# INLINE rule2319 #-}
   rule2319 = \ ((_guardIuniqueSecondRound) :: Int) ->
     _guardIuniqueSecondRound

-- GuardedExpressions ------------------------------------------
-- wrapper
data Inh_GuardedExpressions  = Inh_GuardedExpressions { allPatterns_Inh_GuardedExpressions :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_GuardedExpressions :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_GuardedExpressions :: (Predicates), betaRight_Inh_GuardedExpressions :: (Tp), betaUnique_Inh_GuardedExpressions :: (Int), classEnvironment_Inh_GuardedExpressions :: (ClassEnvironment), collectErrors_Inh_GuardedExpressions :: (TypeErrors), collectWarnings_Inh_GuardedExpressions :: (Warnings), counter_Inh_GuardedExpressions :: (Int), currentChunk_Inh_GuardedExpressions :: (Int), dictionaryEnvironment_Inh_GuardedExpressions :: (DictionaryEnvironment), importEnvironment_Inh_GuardedExpressions :: (ImportEnvironment), matchIO_Inh_GuardedExpressions :: (IO ()), monos_Inh_GuardedExpressions :: (Monos), namesInScope_Inh_GuardedExpressions :: (Names), numberOfGuards_Inh_GuardedExpressions :: (Int), open_Inh_GuardedExpressions :: (Bool), orderedTypeSynonyms_Inh_GuardedExpressions :: (OrderedTypeSynonyms), parentTree_Inh_GuardedExpressions :: (InfoTree), patternMatchWarnings_Inh_GuardedExpressions :: ([Warning]), substitution_Inh_GuardedExpressions :: (FixpointSubstitution), typeschemeMap_Inh_GuardedExpressions :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_GuardedExpressions :: (Int), uniqueSecondRound_Inh_GuardedExpressions :: (Int) }
data Syn_GuardedExpressions  = Syn_GuardedExpressions { assumptions_Syn_GuardedExpressions :: (Assumptions), betaUnique_Syn_GuardedExpressions :: (Int), collectErrors_Syn_GuardedExpressions :: (TypeErrors), collectInstances_Syn_GuardedExpressions :: ([(Name, Instance)]), collectWarnings_Syn_GuardedExpressions :: (Warnings), constraintslist_Syn_GuardedExpressions :: (ConstraintSets), counter_Syn_GuardedExpressions :: (Int), dictionaryEnvironment_Syn_GuardedExpressions :: (DictionaryEnvironment), fallthrough_Syn_GuardedExpressions :: (Bool), infoTrees_Syn_GuardedExpressions :: (InfoTrees), matchIO_Syn_GuardedExpressions :: (IO ()), patternMatchWarnings_Syn_GuardedExpressions :: ([Warning]), self_Syn_GuardedExpressions :: (GuardedExpressions), unboundNames_Syn_GuardedExpressions :: (Names), uniqueChunk_Syn_GuardedExpressions :: (Int), uniqueSecondRound_Syn_GuardedExpressions :: (Int) }
{-# INLINABLE wrap_GuardedExpressions #-}
wrap_GuardedExpressions :: T_GuardedExpressions  -> Inh_GuardedExpressions  -> (Syn_GuardedExpressions )
wrap_GuardedExpressions (T_GuardedExpressions act) (Inh_GuardedExpressions _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_GuardedExpressions_vIn64 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_GuardedExpressions_vOut64 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_GuardedExpressions_s65 sem arg)
        return (Syn_GuardedExpressions _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_GuardedExpressions #-}
sem_GuardedExpressions :: GuardedExpressions  -> T_GuardedExpressions 
sem_GuardedExpressions list = Prelude.foldr sem_GuardedExpressions_Cons sem_GuardedExpressions_Nil (Prelude.map sem_GuardedExpression list)

-- semantic domain
newtype T_GuardedExpressions  = T_GuardedExpressions {
                                                     attach_T_GuardedExpressions :: Identity (T_GuardedExpressions_s65 )
                                                     }
newtype T_GuardedExpressions_s65  = C_GuardedExpressions_s65 {
                                                             inv_GuardedExpressions_s65 :: (T_GuardedExpressions_v64 )
                                                             }
data T_GuardedExpressions_s66  = C_GuardedExpressions_s66
type T_GuardedExpressions_v64  = (T_GuardedExpressions_vIn64 ) -> (T_GuardedExpressions_vOut64 )
data T_GuardedExpressions_vIn64  = T_GuardedExpressions_vIn64 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (Int) (Bool) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_GuardedExpressions_vOut64  = T_GuardedExpressions_vOut64 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSets) (Int) (DictionaryEnvironment) (Bool) (InfoTrees) (IO ()) ([Warning]) (GuardedExpressions) (Names) (Int) (Int)
{-# NOINLINE sem_GuardedExpressions_Cons #-}
sem_GuardedExpressions_Cons :: T_GuardedExpression  -> T_GuardedExpressions  -> T_GuardedExpressions 
sem_GuardedExpressions_Cons arg_hd_ arg_tl_ = T_GuardedExpressions (return st65) where
   {-# NOINLINE st65 #-}
   st65 = let
      v64 :: T_GuardedExpressions_v64 
      v64 = \ (T_GuardedExpressions_vIn64 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _hdX62 = Control.Monad.Identity.runIdentity (attach_T_GuardedExpression (arg_hd_))
         _tlX65 = Control.Monad.Identity.runIdentity (attach_T_GuardedExpressions (arg_tl_))
         (T_GuardedExpression_vOut61 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIfallthrough _hdIinfoTrees _hdImatchIO _hdIpatternMatchWarnings _hdIrange _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound _hdIunrwar) = inv_GuardedExpression_s62 _hdX62 (T_GuardedExpression_vIn61 _hdOallPatterns _hdOallTypeSchemes _hdOavailablePredicates _hdObetaRight _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOnumberOfGuards _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk _hdOuniqueSecondRound)
         (T_GuardedExpressions_vOut64 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraintslist _tlIcounter _tlIdictionaryEnvironment _tlIfallthrough _tlIinfoTrees _tlImatchIO _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_GuardedExpressions_s65 _tlX65 (T_GuardedExpressions_vIn64 _tlOallPatterns _tlOallTypeSchemes _tlOavailablePredicates _tlObetaRight _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOnumberOfGuards _tlOopen _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk _tlOuniqueSecondRound)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2320 _hdIassumptions _tlIassumptions
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule2321 _hdIconstraints _tlIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2322 _hdIinfoTrees _tlIinfoTrees
         _lhsOfallthrough :: Bool
         _lhsOfallthrough = rule2323 _hdIfallthrough _tlIfallthrough
         _tlOopen = rule2324 _hdIfallthrough _lhsIopen
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2325 _hdIunrwar _lhsIopen _tlIpatternMatchWarnings
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2326 _hdIcollectInstances _tlIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2327 _hdIunboundNames _tlIunboundNames
         _self = rule2328 _hdIself _tlIself
         _lhsOself :: GuardedExpressions
         _lhsOself = rule2329 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2330 _tlIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2331 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2332 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2333 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2334 _tlIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2335 _tlImatchIO
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2336 _tlIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule2337 _tlIuniqueSecondRound
         _hdOallPatterns = rule2338 _lhsIallPatterns
         _hdOallTypeSchemes = rule2339 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule2340 _lhsIavailablePredicates
         _hdObetaRight = rule2341 _lhsIbetaRight
         _hdObetaUnique = rule2342 _lhsIbetaUnique
         _hdOclassEnvironment = rule2343 _lhsIclassEnvironment
         _hdOcollectErrors = rule2344 _lhsIcollectErrors
         _hdOcollectWarnings = rule2345 _lhsIcollectWarnings
         _hdOcounter = rule2346 _lhsIcounter
         _hdOcurrentChunk = rule2347 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule2348 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule2349 _lhsIimportEnvironment
         _hdOmatchIO = rule2350 _lhsImatchIO
         _hdOmonos = rule2351 _lhsImonos
         _hdOnamesInScope = rule2352 _lhsInamesInScope
         _hdOnumberOfGuards = rule2353 _lhsInumberOfGuards
         _hdOorderedTypeSynonyms = rule2354 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule2355 _lhsIparentTree
         _hdOpatternMatchWarnings = rule2356 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule2357 _lhsIsubstitution
         _hdOtypeschemeMap = rule2358 _lhsItypeschemeMap
         _hdOuniqueChunk = rule2359 _lhsIuniqueChunk
         _hdOuniqueSecondRound = rule2360 _lhsIuniqueSecondRound
         _tlOallPatterns = rule2361 _lhsIallPatterns
         _tlOallTypeSchemes = rule2362 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule2363 _lhsIavailablePredicates
         _tlObetaRight = rule2364 _lhsIbetaRight
         _tlObetaUnique = rule2365 _hdIbetaUnique
         _tlOclassEnvironment = rule2366 _lhsIclassEnvironment
         _tlOcollectErrors = rule2367 _hdIcollectErrors
         _tlOcollectWarnings = rule2368 _hdIcollectWarnings
         _tlOcounter = rule2369 _hdIcounter
         _tlOcurrentChunk = rule2370 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule2371 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule2372 _lhsIimportEnvironment
         _tlOmatchIO = rule2373 _hdImatchIO
         _tlOmonos = rule2374 _lhsImonos
         _tlOnamesInScope = rule2375 _lhsInamesInScope
         _tlOnumberOfGuards = rule2376 _lhsInumberOfGuards
         _tlOorderedTypeSynonyms = rule2377 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule2378 _lhsIparentTree
         _tlOpatternMatchWarnings = rule2379 _hdIpatternMatchWarnings
         _tlOsubstitution = rule2380 _lhsIsubstitution
         _tlOtypeschemeMap = rule2381 _lhsItypeschemeMap
         _tlOuniqueChunk = rule2382 _hdIuniqueChunk
         _tlOuniqueSecondRound = rule2383 _hdIuniqueSecondRound
         __result_ = T_GuardedExpressions_vOut64 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_GuardedExpressions_s65 v64
   {-# INLINE rule2320 #-}
   rule2320 = \ ((_hdIassumptions) :: Assumptions) ((_tlIassumptions) :: Assumptions) ->
                                _hdIassumptions `combine` _tlIassumptions
   {-# INLINE rule2321 #-}
   rule2321 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
                                _hdIconstraints : _tlIconstraintslist
   {-# INLINE rule2322 #-}
   rule2322 = \ ((_hdIinfoTrees) :: InfoTrees) ((_tlIinfoTrees) :: InfoTrees) ->
                                _hdIinfoTrees ++ _tlIinfoTrees
   {-# INLINE rule2323 #-}
   rule2323 = \ ((_hdIfallthrough) :: Bool) ((_tlIfallthrough) :: Bool) ->
                                            _hdIfallthrough && _tlIfallthrough
   {-# INLINE rule2324 #-}
   rule2324 = \ ((_hdIfallthrough) :: Bool) ((_lhsIopen) :: Bool) ->
                                            _hdIfallthrough && _lhsIopen
   {-# INLINE rule2325 #-}
   rule2325 = \ ((_hdIunrwar) :: Warning) ((_lhsIopen) :: Bool) ((_tlIpatternMatchWarnings) :: [Warning]) ->
                                                     (if not _lhsIopen then [_hdIunrwar] else [])
                                                     ++ _tlIpatternMatchWarnings
   {-# INLINE rule2326 #-}
   rule2326 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule2327 #-}
   rule2327 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule2328 #-}
   rule2328 = \ ((_hdIself) :: GuardedExpression) ((_tlIself) :: GuardedExpressions) ->
     (:) _hdIself _tlIself
   {-# INLINE rule2329 #-}
   rule2329 = \ _self ->
     _self
   {-# INLINE rule2330 #-}
   rule2330 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule2331 #-}
   rule2331 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule2332 #-}
   rule2332 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule2333 #-}
   rule2333 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule2334 #-}
   rule2334 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule2335 #-}
   rule2335 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule2336 #-}
   rule2336 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule2337 #-}
   rule2337 = \ ((_tlIuniqueSecondRound) :: Int) ->
     _tlIuniqueSecondRound
   {-# INLINE rule2338 #-}
   rule2338 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2339 #-}
   rule2339 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2340 #-}
   rule2340 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2341 #-}
   rule2341 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule2342 #-}
   rule2342 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2343 #-}
   rule2343 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2344 #-}
   rule2344 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2345 #-}
   rule2345 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2346 #-}
   rule2346 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2347 #-}
   rule2347 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2348 #-}
   rule2348 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2349 #-}
   rule2349 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2350 #-}
   rule2350 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2351 #-}
   rule2351 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2352 #-}
   rule2352 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2353 #-}
   rule2353 = \ ((_lhsInumberOfGuards) :: Int) ->
     _lhsInumberOfGuards
   {-# INLINE rule2354 #-}
   rule2354 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2355 #-}
   rule2355 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2356 #-}
   rule2356 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2357 #-}
   rule2357 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2358 #-}
   rule2358 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2359 #-}
   rule2359 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2360 #-}
   rule2360 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule2361 #-}
   rule2361 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2362 #-}
   rule2362 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2363 #-}
   rule2363 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2364 #-}
   rule2364 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule2365 #-}
   rule2365 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule2366 #-}
   rule2366 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2367 #-}
   rule2367 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule2368 #-}
   rule2368 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule2369 #-}
   rule2369 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule2370 #-}
   rule2370 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2371 #-}
   rule2371 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule2372 #-}
   rule2372 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2373 #-}
   rule2373 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule2374 #-}
   rule2374 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2375 #-}
   rule2375 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2376 #-}
   rule2376 = \ ((_lhsInumberOfGuards) :: Int) ->
     _lhsInumberOfGuards
   {-# INLINE rule2377 #-}
   rule2377 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2378 #-}
   rule2378 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2379 #-}
   rule2379 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule2380 #-}
   rule2380 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2381 #-}
   rule2381 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2382 #-}
   rule2382 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
   {-# INLINE rule2383 #-}
   rule2383 = \ ((_hdIuniqueSecondRound) :: Int) ->
     _hdIuniqueSecondRound
{-# NOINLINE sem_GuardedExpressions_Nil #-}
sem_GuardedExpressions_Nil ::  T_GuardedExpressions 
sem_GuardedExpressions_Nil  = T_GuardedExpressions (return st65) where
   {-# NOINLINE st65 #-}
   st65 = let
      v64 :: T_GuardedExpressions_v64 
      v64 = \ (T_GuardedExpressions_vIn64 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsInumberOfGuards _lhsIopen _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2384  ()
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule2385  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2386  ()
         _lhsOfallthrough :: Bool
         _lhsOfallthrough = rule2387  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2388  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2389  ()
         _self = rule2390  ()
         _lhsOself :: GuardedExpressions
         _lhsOself = rule2391 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2392 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2393 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2394 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2395 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2396 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2397 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2398 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2399 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule2400 _lhsIuniqueSecondRound
         __result_ = T_GuardedExpressions_vOut64 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraintslist _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTrees _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_GuardedExpressions_s65 v64
   {-# INLINE rule2384 #-}
   rule2384 = \  (_ :: ()) ->
                                noAssumptions
   {-# INLINE rule2385 #-}
   rule2385 = \  (_ :: ()) ->
                                []
   {-# INLINE rule2386 #-}
   rule2386 = \  (_ :: ()) ->
                                []
   {-# INLINE rule2387 #-}
   rule2387 = \  (_ :: ()) ->
                                            True
   {-# INLINE rule2388 #-}
   rule2388 = \  (_ :: ()) ->
     []
   {-# INLINE rule2389 #-}
   rule2389 = \  (_ :: ()) ->
     []
   {-# INLINE rule2390 #-}
   rule2390 = \  (_ :: ()) ->
     []
   {-# INLINE rule2391 #-}
   rule2391 = \ _self ->
     _self
   {-# INLINE rule2392 #-}
   rule2392 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2393 #-}
   rule2393 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2394 #-}
   rule2394 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2395 #-}
   rule2395 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2396 #-}
   rule2396 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2397 #-}
   rule2397 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2398 #-}
   rule2398 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2399 #-}
   rule2399 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2400 #-}
   rule2400 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- Import ------------------------------------------------------
-- wrapper
data Inh_Import  = Inh_Import {  }
data Syn_Import  = Syn_Import { self_Syn_Import :: (Import) }
{-# INLINABLE wrap_Import #-}
wrap_Import :: T_Import  -> Inh_Import  -> (Syn_Import )
wrap_Import (T_Import act) (Inh_Import ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Import_vIn67 
        (T_Import_vOut67 _lhsOself) <- return (inv_Import_s68 sem arg)
        return (Syn_Import _lhsOself)
   )

-- cata
{-# NOINLINE sem_Import #-}
sem_Import :: Import  -> T_Import 
sem_Import ( Import_Variable range_ name_ ) = sem_Import_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Import ( Import_TypeOrClass range_ name_ names_ ) = sem_Import_TypeOrClass ( sem_Range range_ ) ( sem_Name name_ ) ( sem_MaybeNames names_ )
sem_Import ( Import_TypeOrClassComplete range_ name_ ) = sem_Import_TypeOrClassComplete ( sem_Range range_ ) ( sem_Name name_ )

-- semantic domain
newtype T_Import  = T_Import {
                             attach_T_Import :: Identity (T_Import_s68 )
                             }
newtype T_Import_s68  = C_Import_s68 {
                                     inv_Import_s68 :: (T_Import_v67 )
                                     }
data T_Import_s69  = C_Import_s69
type T_Import_v67  = (T_Import_vIn67 ) -> (T_Import_vOut67 )
data T_Import_vIn67  = T_Import_vIn67 
data T_Import_vOut67  = T_Import_vOut67 (Import)
{-# NOINLINE sem_Import_Variable #-}
sem_Import_Variable :: T_Range  -> T_Name  -> T_Import 
sem_Import_Variable arg_range_ arg_name_ = T_Import (return st68) where
   {-# NOINLINE st68 #-}
   st68 = let
      v67 :: T_Import_v67 
      v67 = \ (T_Import_vIn67 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule2401 _nameIself _rangeIself
         _lhsOself :: Import
         _lhsOself = rule2402 _self
         __result_ = T_Import_vOut67 _lhsOself
         in __result_ )
     in C_Import_s68 v67
   {-# INLINE rule2401 #-}
   rule2401 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Import_Variable _rangeIself _nameIself
   {-# INLINE rule2402 #-}
   rule2402 = \ _self ->
     _self
{-# NOINLINE sem_Import_TypeOrClass #-}
sem_Import_TypeOrClass :: T_Range  -> T_Name  -> T_MaybeNames  -> T_Import 
sem_Import_TypeOrClass arg_range_ arg_name_ arg_names_ = T_Import (return st68) where
   {-# NOINLINE st68 #-}
   st68 = let
      v67 :: T_Import_v67 
      v67 = \ (T_Import_vIn67 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _namesX107 = Control.Monad.Identity.runIdentity (attach_T_MaybeNames (arg_names_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_MaybeNames_vOut106 _namesIself) = inv_MaybeNames_s107 _namesX107 (T_MaybeNames_vIn106 )
         _self = rule2403 _nameIself _namesIself _rangeIself
         _lhsOself :: Import
         _lhsOself = rule2404 _self
         __result_ = T_Import_vOut67 _lhsOself
         in __result_ )
     in C_Import_s68 v67
   {-# INLINE rule2403 #-}
   rule2403 = \ ((_nameIself) :: Name) ((_namesIself) :: MaybeNames) ((_rangeIself) :: Range) ->
     Import_TypeOrClass _rangeIself _nameIself _namesIself
   {-# INLINE rule2404 #-}
   rule2404 = \ _self ->
     _self
{-# NOINLINE sem_Import_TypeOrClassComplete #-}
sem_Import_TypeOrClassComplete :: T_Range  -> T_Name  -> T_Import 
sem_Import_TypeOrClassComplete arg_range_ arg_name_ = T_Import (return st68) where
   {-# NOINLINE st68 #-}
   st68 = let
      v67 :: T_Import_v67 
      v67 = \ (T_Import_vIn67 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule2405 _nameIself _rangeIself
         _lhsOself :: Import
         _lhsOself = rule2406 _self
         __result_ = T_Import_vOut67 _lhsOself
         in __result_ )
     in C_Import_s68 v67
   {-# INLINE rule2405 #-}
   rule2405 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Import_TypeOrClassComplete _rangeIself _nameIself
   {-# INLINE rule2406 #-}
   rule2406 = \ _self ->
     _self

-- ImportDeclaration -------------------------------------------
-- wrapper
data Inh_ImportDeclaration  = Inh_ImportDeclaration {  }
data Syn_ImportDeclaration  = Syn_ImportDeclaration { self_Syn_ImportDeclaration :: (ImportDeclaration) }
{-# INLINABLE wrap_ImportDeclaration #-}
wrap_ImportDeclaration :: T_ImportDeclaration  -> Inh_ImportDeclaration  -> (Syn_ImportDeclaration )
wrap_ImportDeclaration (T_ImportDeclaration act) (Inh_ImportDeclaration ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_ImportDeclaration_vIn70 
        (T_ImportDeclaration_vOut70 _lhsOself) <- return (inv_ImportDeclaration_s71 sem arg)
        return (Syn_ImportDeclaration _lhsOself)
   )

-- cata
{-# NOINLINE sem_ImportDeclaration #-}
sem_ImportDeclaration :: ImportDeclaration  -> T_ImportDeclaration 
sem_ImportDeclaration ( ImportDeclaration_Import range_ qualified_ name_ asname_ importspecification_ ) = sem_ImportDeclaration_Import ( sem_Range range_ ) qualified_ ( sem_Name name_ ) ( sem_MaybeName asname_ ) ( sem_MaybeImportSpecification importspecification_ )
sem_ImportDeclaration ( ImportDeclaration_Empty range_ ) = sem_ImportDeclaration_Empty ( sem_Range range_ )

-- semantic domain
newtype T_ImportDeclaration  = T_ImportDeclaration {
                                                   attach_T_ImportDeclaration :: Identity (T_ImportDeclaration_s71 )
                                                   }
newtype T_ImportDeclaration_s71  = C_ImportDeclaration_s71 {
                                                           inv_ImportDeclaration_s71 :: (T_ImportDeclaration_v70 )
                                                           }
data T_ImportDeclaration_s72  = C_ImportDeclaration_s72
type T_ImportDeclaration_v70  = (T_ImportDeclaration_vIn70 ) -> (T_ImportDeclaration_vOut70 )
data T_ImportDeclaration_vIn70  = T_ImportDeclaration_vIn70 
data T_ImportDeclaration_vOut70  = T_ImportDeclaration_vOut70 (ImportDeclaration)
{-# NOINLINE sem_ImportDeclaration_Import #-}
sem_ImportDeclaration_Import :: T_Range  -> (Bool) -> T_Name  -> T_MaybeName  -> T_MaybeImportSpecification  -> T_ImportDeclaration 
sem_ImportDeclaration_Import arg_range_ arg_qualified_ arg_name_ arg_asname_ arg_importspecification_ = T_ImportDeclaration (return st71) where
   {-# NOINLINE st71 #-}
   st71 = let
      v70 :: T_ImportDeclaration_v70 
      v70 = \ (T_ImportDeclaration_vIn70 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _asnameX104 = Control.Monad.Identity.runIdentity (attach_T_MaybeName (arg_asname_))
         _importspecificationX98 = Control.Monad.Identity.runIdentity (attach_T_MaybeImportSpecification (arg_importspecification_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_MaybeName_vOut103 _asnameIself) = inv_MaybeName_s104 _asnameX104 (T_MaybeName_vIn103 )
         (T_MaybeImportSpecification_vOut97 _importspecificationIself) = inv_MaybeImportSpecification_s98 _importspecificationX98 (T_MaybeImportSpecification_vIn97 )
         _self = rule2407 _asnameIself _importspecificationIself _nameIself _rangeIself arg_qualified_
         _lhsOself :: ImportDeclaration
         _lhsOself = rule2408 _self
         __result_ = T_ImportDeclaration_vOut70 _lhsOself
         in __result_ )
     in C_ImportDeclaration_s71 v70
   {-# INLINE rule2407 #-}
   rule2407 = \ ((_asnameIself) :: MaybeName) ((_importspecificationIself) :: MaybeImportSpecification) ((_nameIself) :: Name) ((_rangeIself) :: Range) qualified_ ->
     ImportDeclaration_Import _rangeIself qualified_ _nameIself _asnameIself _importspecificationIself
   {-# INLINE rule2408 #-}
   rule2408 = \ _self ->
     _self
{-# NOINLINE sem_ImportDeclaration_Empty #-}
sem_ImportDeclaration_Empty :: T_Range  -> T_ImportDeclaration 
sem_ImportDeclaration_Empty arg_range_ = T_ImportDeclaration (return st71) where
   {-# NOINLINE st71 #-}
   st71 = let
      v70 :: T_ImportDeclaration_v70 
      v70 = \ (T_ImportDeclaration_vIn70 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _self = rule2409 _rangeIself
         _lhsOself :: ImportDeclaration
         _lhsOself = rule2410 _self
         __result_ = T_ImportDeclaration_vOut70 _lhsOself
         in __result_ )
     in C_ImportDeclaration_s71 v70
   {-# INLINE rule2409 #-}
   rule2409 = \ ((_rangeIself) :: Range) ->
     ImportDeclaration_Empty _rangeIself
   {-# INLINE rule2410 #-}
   rule2410 = \ _self ->
     _self

-- ImportDeclarations ------------------------------------------
-- wrapper
data Inh_ImportDeclarations  = Inh_ImportDeclarations {  }
data Syn_ImportDeclarations  = Syn_ImportDeclarations { self_Syn_ImportDeclarations :: (ImportDeclarations) }
{-# INLINABLE wrap_ImportDeclarations #-}
wrap_ImportDeclarations :: T_ImportDeclarations  -> Inh_ImportDeclarations  -> (Syn_ImportDeclarations )
wrap_ImportDeclarations (T_ImportDeclarations act) (Inh_ImportDeclarations ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_ImportDeclarations_vIn73 
        (T_ImportDeclarations_vOut73 _lhsOself) <- return (inv_ImportDeclarations_s74 sem arg)
        return (Syn_ImportDeclarations _lhsOself)
   )

-- cata
{-# NOINLINE sem_ImportDeclarations #-}
sem_ImportDeclarations :: ImportDeclarations  -> T_ImportDeclarations 
sem_ImportDeclarations list = Prelude.foldr sem_ImportDeclarations_Cons sem_ImportDeclarations_Nil (Prelude.map sem_ImportDeclaration list)

-- semantic domain
newtype T_ImportDeclarations  = T_ImportDeclarations {
                                                     attach_T_ImportDeclarations :: Identity (T_ImportDeclarations_s74 )
                                                     }
newtype T_ImportDeclarations_s74  = C_ImportDeclarations_s74 {
                                                             inv_ImportDeclarations_s74 :: (T_ImportDeclarations_v73 )
                                                             }
data T_ImportDeclarations_s75  = C_ImportDeclarations_s75
type T_ImportDeclarations_v73  = (T_ImportDeclarations_vIn73 ) -> (T_ImportDeclarations_vOut73 )
data T_ImportDeclarations_vIn73  = T_ImportDeclarations_vIn73 
data T_ImportDeclarations_vOut73  = T_ImportDeclarations_vOut73 (ImportDeclarations)
{-# NOINLINE sem_ImportDeclarations_Cons #-}
sem_ImportDeclarations_Cons :: T_ImportDeclaration  -> T_ImportDeclarations  -> T_ImportDeclarations 
sem_ImportDeclarations_Cons arg_hd_ arg_tl_ = T_ImportDeclarations (return st74) where
   {-# NOINLINE st74 #-}
   st74 = let
      v73 :: T_ImportDeclarations_v73 
      v73 = \ (T_ImportDeclarations_vIn73 ) -> ( let
         _hdX71 = Control.Monad.Identity.runIdentity (attach_T_ImportDeclaration (arg_hd_))
         _tlX74 = Control.Monad.Identity.runIdentity (attach_T_ImportDeclarations (arg_tl_))
         (T_ImportDeclaration_vOut70 _hdIself) = inv_ImportDeclaration_s71 _hdX71 (T_ImportDeclaration_vIn70 )
         (T_ImportDeclarations_vOut73 _tlIself) = inv_ImportDeclarations_s74 _tlX74 (T_ImportDeclarations_vIn73 )
         _self = rule2411 _hdIself _tlIself
         _lhsOself :: ImportDeclarations
         _lhsOself = rule2412 _self
         __result_ = T_ImportDeclarations_vOut73 _lhsOself
         in __result_ )
     in C_ImportDeclarations_s74 v73
   {-# INLINE rule2411 #-}
   rule2411 = \ ((_hdIself) :: ImportDeclaration) ((_tlIself) :: ImportDeclarations) ->
     (:) _hdIself _tlIself
   {-# INLINE rule2412 #-}
   rule2412 = \ _self ->
     _self
{-# NOINLINE sem_ImportDeclarations_Nil #-}
sem_ImportDeclarations_Nil ::  T_ImportDeclarations 
sem_ImportDeclarations_Nil  = T_ImportDeclarations (return st74) where
   {-# NOINLINE st74 #-}
   st74 = let
      v73 :: T_ImportDeclarations_v73 
      v73 = \ (T_ImportDeclarations_vIn73 ) -> ( let
         _self = rule2413  ()
         _lhsOself :: ImportDeclarations
         _lhsOself = rule2414 _self
         __result_ = T_ImportDeclarations_vOut73 _lhsOself
         in __result_ )
     in C_ImportDeclarations_s74 v73
   {-# INLINE rule2413 #-}
   rule2413 = \  (_ :: ()) ->
     []
   {-# INLINE rule2414 #-}
   rule2414 = \ _self ->
     _self

-- ImportSpecification -----------------------------------------
-- wrapper
data Inh_ImportSpecification  = Inh_ImportSpecification {  }
data Syn_ImportSpecification  = Syn_ImportSpecification { self_Syn_ImportSpecification :: (ImportSpecification) }
{-# INLINABLE wrap_ImportSpecification #-}
wrap_ImportSpecification :: T_ImportSpecification  -> Inh_ImportSpecification  -> (Syn_ImportSpecification )
wrap_ImportSpecification (T_ImportSpecification act) (Inh_ImportSpecification ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_ImportSpecification_vIn76 
        (T_ImportSpecification_vOut76 _lhsOself) <- return (inv_ImportSpecification_s77 sem arg)
        return (Syn_ImportSpecification _lhsOself)
   )

-- cata
{-# INLINE sem_ImportSpecification #-}
sem_ImportSpecification :: ImportSpecification  -> T_ImportSpecification 
sem_ImportSpecification ( ImportSpecification_Import range_ hiding_ imports_ ) = sem_ImportSpecification_Import ( sem_Range range_ ) hiding_ ( sem_Imports imports_ )

-- semantic domain
newtype T_ImportSpecification  = T_ImportSpecification {
                                                       attach_T_ImportSpecification :: Identity (T_ImportSpecification_s77 )
                                                       }
newtype T_ImportSpecification_s77  = C_ImportSpecification_s77 {
                                                               inv_ImportSpecification_s77 :: (T_ImportSpecification_v76 )
                                                               }
data T_ImportSpecification_s78  = C_ImportSpecification_s78
type T_ImportSpecification_v76  = (T_ImportSpecification_vIn76 ) -> (T_ImportSpecification_vOut76 )
data T_ImportSpecification_vIn76  = T_ImportSpecification_vIn76 
data T_ImportSpecification_vOut76  = T_ImportSpecification_vOut76 (ImportSpecification)
{-# NOINLINE sem_ImportSpecification_Import #-}
sem_ImportSpecification_Import :: T_Range  -> (Bool) -> T_Imports  -> T_ImportSpecification 
sem_ImportSpecification_Import arg_range_ arg_hiding_ arg_imports_ = T_ImportSpecification (return st77) where
   {-# NOINLINE st77 #-}
   st77 = let
      v76 :: T_ImportSpecification_v76 
      v76 = \ (T_ImportSpecification_vIn76 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _importsX80 = Control.Monad.Identity.runIdentity (attach_T_Imports (arg_imports_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Imports_vOut79 _importsIself) = inv_Imports_s80 _importsX80 (T_Imports_vIn79 )
         _self = rule2415 _importsIself _rangeIself arg_hiding_
         _lhsOself :: ImportSpecification
         _lhsOself = rule2416 _self
         __result_ = T_ImportSpecification_vOut76 _lhsOself
         in __result_ )
     in C_ImportSpecification_s77 v76
   {-# INLINE rule2415 #-}
   rule2415 = \ ((_importsIself) :: Imports) ((_rangeIself) :: Range) hiding_ ->
     ImportSpecification_Import _rangeIself hiding_ _importsIself
   {-# INLINE rule2416 #-}
   rule2416 = \ _self ->
     _self

-- Imports -----------------------------------------------------
-- wrapper
data Inh_Imports  = Inh_Imports {  }
data Syn_Imports  = Syn_Imports { self_Syn_Imports :: (Imports) }
{-# INLINABLE wrap_Imports #-}
wrap_Imports :: T_Imports  -> Inh_Imports  -> (Syn_Imports )
wrap_Imports (T_Imports act) (Inh_Imports ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Imports_vIn79 
        (T_Imports_vOut79 _lhsOself) <- return (inv_Imports_s80 sem arg)
        return (Syn_Imports _lhsOself)
   )

-- cata
{-# NOINLINE sem_Imports #-}
sem_Imports :: Imports  -> T_Imports 
sem_Imports list = Prelude.foldr sem_Imports_Cons sem_Imports_Nil (Prelude.map sem_Import list)

-- semantic domain
newtype T_Imports  = T_Imports {
                               attach_T_Imports :: Identity (T_Imports_s80 )
                               }
newtype T_Imports_s80  = C_Imports_s80 {
                                       inv_Imports_s80 :: (T_Imports_v79 )
                                       }
data T_Imports_s81  = C_Imports_s81
type T_Imports_v79  = (T_Imports_vIn79 ) -> (T_Imports_vOut79 )
data T_Imports_vIn79  = T_Imports_vIn79 
data T_Imports_vOut79  = T_Imports_vOut79 (Imports)
{-# NOINLINE sem_Imports_Cons #-}
sem_Imports_Cons :: T_Import  -> T_Imports  -> T_Imports 
sem_Imports_Cons arg_hd_ arg_tl_ = T_Imports (return st80) where
   {-# NOINLINE st80 #-}
   st80 = let
      v79 :: T_Imports_v79 
      v79 = \ (T_Imports_vIn79 ) -> ( let
         _hdX68 = Control.Monad.Identity.runIdentity (attach_T_Import (arg_hd_))
         _tlX80 = Control.Monad.Identity.runIdentity (attach_T_Imports (arg_tl_))
         (T_Import_vOut67 _hdIself) = inv_Import_s68 _hdX68 (T_Import_vIn67 )
         (T_Imports_vOut79 _tlIself) = inv_Imports_s80 _tlX80 (T_Imports_vIn79 )
         _self = rule2417 _hdIself _tlIself
         _lhsOself :: Imports
         _lhsOself = rule2418 _self
         __result_ = T_Imports_vOut79 _lhsOself
         in __result_ )
     in C_Imports_s80 v79
   {-# INLINE rule2417 #-}
   rule2417 = \ ((_hdIself) :: Import) ((_tlIself) :: Imports) ->
     (:) _hdIself _tlIself
   {-# INLINE rule2418 #-}
   rule2418 = \ _self ->
     _self
{-# NOINLINE sem_Imports_Nil #-}
sem_Imports_Nil ::  T_Imports 
sem_Imports_Nil  = T_Imports (return st80) where
   {-# NOINLINE st80 #-}
   st80 = let
      v79 :: T_Imports_v79 
      v79 = \ (T_Imports_vIn79 ) -> ( let
         _self = rule2419  ()
         _lhsOself :: Imports
         _lhsOself = rule2420 _self
         __result_ = T_Imports_vOut79 _lhsOself
         in __result_ )
     in C_Imports_s80 v79
   {-# INLINE rule2419 #-}
   rule2419 = \  (_ :: ()) ->
     []
   {-# INLINE rule2420 #-}
   rule2420 = \ _self ->
     _self

-- LeftHandSide ------------------------------------------------
-- wrapper
data Inh_LeftHandSide  = Inh_LeftHandSide { betaUnique_Inh_LeftHandSide :: (Int), counter_Inh_LeftHandSide :: (Int), importEnvironment_Inh_LeftHandSide :: (ImportEnvironment), monos_Inh_LeftHandSide :: (Monos), namesInScope_Inh_LeftHandSide :: (Names), parentTree_Inh_LeftHandSide :: (InfoTree), patternMatchWarnings_Inh_LeftHandSide :: ([Warning]) }
data Syn_LeftHandSide  = Syn_LeftHandSide { argcount_Syn_LeftHandSide :: (Int), betaUnique_Syn_LeftHandSide :: (Int), betas_Syn_LeftHandSide :: (Tps), constraints_Syn_LeftHandSide :: (ConstraintSet), counter_Syn_LeftHandSide :: (Int), elements_Syn_LeftHandSide :: (  [PatternElement]        ), environment_Syn_LeftHandSide :: (PatternAssumptions), infoTrees_Syn_LeftHandSide :: (InfoTrees), name_Syn_LeftHandSide :: (Name), numberOfPatterns_Syn_LeftHandSide :: (Int), patVarNames_Syn_LeftHandSide :: (Names), patternMatchWarnings_Syn_LeftHandSide :: ([Warning]), self_Syn_LeftHandSide :: (LeftHandSide), unboundNames_Syn_LeftHandSide :: (Names) }
{-# INLINABLE wrap_LeftHandSide #-}
wrap_LeftHandSide :: T_LeftHandSide  -> Inh_LeftHandSide  -> (Syn_LeftHandSide )
wrap_LeftHandSide (T_LeftHandSide act) (Inh_LeftHandSide _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings
        (T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_LeftHandSide_s83 sem arg)
        return (Syn_LeftHandSide _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_LeftHandSide #-}
sem_LeftHandSide :: LeftHandSide  -> T_LeftHandSide 
sem_LeftHandSide ( LeftHandSide_Function range_ name_ patterns_ ) = sem_LeftHandSide_Function ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Patterns patterns_ )
sem_LeftHandSide ( LeftHandSide_Infix range_ leftPattern_ operator_ rightPattern_ ) = sem_LeftHandSide_Infix ( sem_Range range_ ) ( sem_Pattern leftPattern_ ) ( sem_Name operator_ ) ( sem_Pattern rightPattern_ )
sem_LeftHandSide ( LeftHandSide_Parenthesized range_ lefthandside_ patterns_ ) = sem_LeftHandSide_Parenthesized ( sem_Range range_ ) ( sem_LeftHandSide lefthandside_ ) ( sem_Patterns patterns_ )

-- semantic domain
newtype T_LeftHandSide  = T_LeftHandSide {
                                         attach_T_LeftHandSide :: Identity (T_LeftHandSide_s83 )
                                         }
newtype T_LeftHandSide_s83  = C_LeftHandSide_s83 {
                                                 inv_LeftHandSide_s83 :: (T_LeftHandSide_v82 )
                                                 }
data T_LeftHandSide_s84  = C_LeftHandSide_s84
type T_LeftHandSide_v82  = (T_LeftHandSide_vIn82 ) -> (T_LeftHandSide_vOut82 )
data T_LeftHandSide_vIn82  = T_LeftHandSide_vIn82 (Int) (Int) (ImportEnvironment) (Monos) (Names) (InfoTree) ([Warning])
data T_LeftHandSide_vOut82  = T_LeftHandSide_vOut82 (Int) (Int) (Tps) (ConstraintSet) (Int) (  [PatternElement]        ) (PatternAssumptions) (InfoTrees) (Name) (Int) (Names) ([Warning]) (LeftHandSide) (Names)
{-# NOINLINE sem_LeftHandSide_Function #-}
sem_LeftHandSide_Function :: T_Range  -> T_Name  -> T_Patterns  -> T_LeftHandSide 
sem_LeftHandSide_Function arg_range_ arg_name_ arg_patterns_ = T_LeftHandSide (return st83) where
   {-# NOINLINE st83 #-}
   st83 = let
      v82 :: T_LeftHandSide_v82 
      v82 = \ (T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
         _lhsOname :: Name
         _lhsOname = rule2421 _nameIself
         _constraints = rule2422 _patternsIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2423 _patternsIinfoTrees
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2424 _patternsIelementss
         _lhsOargcount :: Int
         _lhsOargcount = rule2425 _patternsIself
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2426 _patternsIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2427 _patternsIunboundNames
         _self = rule2428 _nameIself _patternsIself _rangeIself
         _lhsOself :: LeftHandSide
         _lhsOself = rule2429 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2430 _patternsIbetaUnique
         _lhsObetas :: Tps
         _lhsObetas = rule2431 _patternsIbetas
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2432 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2433 _patternsIcounter
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2434 _patternsIenvironment
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2435 _patternsInumberOfPatterns
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2436 _patternsIpatternMatchWarnings
         _patternsObetaUnique = rule2437 _lhsIbetaUnique
         _patternsOcounter = rule2438 _lhsIcounter
         _patternsOimportEnvironment = rule2439 _lhsIimportEnvironment
         _patternsOmonos = rule2440 _lhsImonos
         _patternsOnamesInScope = rule2441 _lhsInamesInScope
         _patternsOparentTree = rule2442 _lhsIparentTree
         _patternsOpatternMatchWarnings = rule2443 _lhsIpatternMatchWarnings
         __result_ = T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_LeftHandSide_s83 v82
   {-# INLINE rule2421 #-}
   rule2421 = \ ((_nameIself) :: Name) ->
                                 _nameIself
   {-# INLINE rule2422 #-}
   rule2422 = \ ((_patternsIconstraintslist) :: ConstraintSets) ->
                                 Node _patternsIconstraintslist
   {-# INLINE rule2423 #-}
   rule2423 = \ ((_patternsIinfoTrees) :: InfoTrees) ->
                                       _patternsIinfoTrees
   {-# INLINE rule2424 #-}
   rule2424 = \ ((_patternsIelementss) :: [ [PatternElement]       ]) ->
                                         concat _patternsIelementss
   {-# INLINE rule2425 #-}
   rule2425 = \ ((_patternsIself) :: Patterns) ->
                                         length _patternsIself
   {-# INLINE rule2426 #-}
   rule2426 = \ ((_patternsIpatVarNames) :: Names) ->
     _patternsIpatVarNames
   {-# INLINE rule2427 #-}
   rule2427 = \ ((_patternsIunboundNames) :: Names) ->
     _patternsIunboundNames
   {-# INLINE rule2428 #-}
   rule2428 = \ ((_nameIself) :: Name) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
     LeftHandSide_Function _rangeIself _nameIself _patternsIself
   {-# INLINE rule2429 #-}
   rule2429 = \ _self ->
     _self
   {-# INLINE rule2430 #-}
   rule2430 = \ ((_patternsIbetaUnique) :: Int) ->
     _patternsIbetaUnique
   {-# INLINE rule2431 #-}
   rule2431 = \ ((_patternsIbetas) :: Tps) ->
     _patternsIbetas
   {-# INLINE rule2432 #-}
   rule2432 = \ _constraints ->
     _constraints
   {-# INLINE rule2433 #-}
   rule2433 = \ ((_patternsIcounter) :: Int) ->
     _patternsIcounter
   {-# INLINE rule2434 #-}
   rule2434 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
     _patternsIenvironment
   {-# INLINE rule2435 #-}
   rule2435 = \ ((_patternsInumberOfPatterns) :: Int) ->
     _patternsInumberOfPatterns
   {-# INLINE rule2436 #-}
   rule2436 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
     _patternsIpatternMatchWarnings
   {-# INLINE rule2437 #-}
   rule2437 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2438 #-}
   rule2438 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2439 #-}
   rule2439 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2440 #-}
   rule2440 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2441 #-}
   rule2441 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2442 #-}
   rule2442 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2443 #-}
   rule2443 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_LeftHandSide_Infix #-}
sem_LeftHandSide_Infix :: T_Range  -> T_Pattern  -> T_Name  -> T_Pattern  -> T_LeftHandSide 
sem_LeftHandSide_Infix arg_range_ arg_leftPattern_ arg_operator_ arg_rightPattern_ = T_LeftHandSide (return st83) where
   {-# NOINLINE st83 #-}
   st83 = let
      v82 :: T_LeftHandSide_v82 
      v82 = \ (T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _leftPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_leftPattern_))
         _operatorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_operator_))
         _rightPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_rightPattern_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _leftPatternIbeta _leftPatternIbetaUnique _leftPatternIconstraints _leftPatternIcounter _leftPatternIelements _leftPatternIenvironment _leftPatternIinfoTree _leftPatternIpatVarNames _leftPatternIpatternMatchWarnings _leftPatternIself _leftPatternIunboundNames) = inv_Pattern_s119 _leftPatternX119 (T_Pattern_vIn118 _leftPatternObetaUnique _leftPatternOcounter _leftPatternOimportEnvironment _leftPatternOmonos _leftPatternOnamesInScope _leftPatternOparentTree _leftPatternOpatternMatchWarnings)
         (T_Name_vOut112 _operatorIself) = inv_Name_s113 _operatorX113 (T_Name_vIn112 )
         (T_Pattern_vOut118 _rightPatternIbeta _rightPatternIbetaUnique _rightPatternIconstraints _rightPatternIcounter _rightPatternIelements _rightPatternIenvironment _rightPatternIinfoTree _rightPatternIpatVarNames _rightPatternIpatternMatchWarnings _rightPatternIself _rightPatternIunboundNames) = inv_Pattern_s119 _rightPatternX119 (T_Pattern_vIn118 _rightPatternObetaUnique _rightPatternOcounter _rightPatternOimportEnvironment _rightPatternOmonos _rightPatternOnamesInScope _rightPatternOparentTree _rightPatternOpatternMatchWarnings)
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2444  ()
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2445 _leftPatternIenvironment _rightPatternIenvironment
         _lhsObetas :: Tps
         _lhsObetas = rule2446 _leftPatternIbeta _rightPatternIbeta
         _lhsOname :: Name
         _lhsOname = rule2447 _operatorIself
         _constraints = rule2448 _leftPatternIconstraints _rightPatternIconstraints
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2449 _leftPatternIinfoTree _rightPatternIinfoTree
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2450 _leftPatternIelements _rightPatternIelements
         _lhsOargcount :: Int
         _lhsOargcount = rule2451  ()
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2452 _leftPatternIpatVarNames _rightPatternIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2453 _leftPatternIunboundNames _rightPatternIunboundNames
         _self = rule2454 _leftPatternIself _operatorIself _rangeIself _rightPatternIself
         _lhsOself :: LeftHandSide
         _lhsOself = rule2455 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2456 _rightPatternIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2457 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2458 _rightPatternIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2459 _rightPatternIpatternMatchWarnings
         _leftPatternObetaUnique = rule2460 _lhsIbetaUnique
         _leftPatternOcounter = rule2461 _lhsIcounter
         _leftPatternOimportEnvironment = rule2462 _lhsIimportEnvironment
         _leftPatternOmonos = rule2463 _lhsImonos
         _leftPatternOnamesInScope = rule2464 _lhsInamesInScope
         _leftPatternOparentTree = rule2465 _lhsIparentTree
         _leftPatternOpatternMatchWarnings = rule2466 _lhsIpatternMatchWarnings
         _rightPatternObetaUnique = rule2467 _leftPatternIbetaUnique
         _rightPatternOcounter = rule2468 _leftPatternIcounter
         _rightPatternOimportEnvironment = rule2469 _lhsIimportEnvironment
         _rightPatternOmonos = rule2470 _lhsImonos
         _rightPatternOnamesInScope = rule2471 _lhsInamesInScope
         _rightPatternOparentTree = rule2472 _lhsIparentTree
         _rightPatternOpatternMatchWarnings = rule2473 _leftPatternIpatternMatchWarnings
         __result_ = T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_LeftHandSide_s83 v82
   {-# INLINE rule2444 #-}
   rule2444 = \  (_ :: ()) ->
                                 2
   {-# INLINE rule2445 #-}
   rule2445 = \ ((_leftPatternIenvironment) :: PatternAssumptions) ((_rightPatternIenvironment) :: PatternAssumptions) ->
                                 _leftPatternIenvironment `M.union` _rightPatternIenvironment
   {-# INLINE rule2446 #-}
   rule2446 = \ ((_leftPatternIbeta) :: Tp) ((_rightPatternIbeta) :: Tp) ->
                                 [_leftPatternIbeta,_rightPatternIbeta]
   {-# INLINE rule2447 #-}
   rule2447 = \ ((_operatorIself) :: Name) ->
                                 _operatorIself
   {-# INLINE rule2448 #-}
   rule2448 = \ ((_leftPatternIconstraints) :: ConstraintSet) ((_rightPatternIconstraints) :: ConstraintSet) ->
                                 Node [ _leftPatternIconstraints
                                      , _rightPatternIconstraints
                                      ]
   {-# INLINE rule2449 #-}
   rule2449 = \ ((_leftPatternIinfoTree) :: InfoTree) ((_rightPatternIinfoTree) :: InfoTree) ->
                                       [_leftPatternIinfoTree, _rightPatternIinfoTree]
   {-# INLINE rule2450 #-}
   rule2450 = \ ((_leftPatternIelements) ::   [PatternElement]        ) ((_rightPatternIelements) ::   [PatternElement]        ) ->
                                         _leftPatternIelements ++ _rightPatternIelements
   {-# INLINE rule2451 #-}
   rule2451 = \  (_ :: ()) ->
                                         2
   {-# INLINE rule2452 #-}
   rule2452 = \ ((_leftPatternIpatVarNames) :: Names) ((_rightPatternIpatVarNames) :: Names) ->
     _leftPatternIpatVarNames ++ _rightPatternIpatVarNames
   {-# INLINE rule2453 #-}
   rule2453 = \ ((_leftPatternIunboundNames) :: Names) ((_rightPatternIunboundNames) :: Names) ->
     _leftPatternIunboundNames ++ _rightPatternIunboundNames
   {-# INLINE rule2454 #-}
   rule2454 = \ ((_leftPatternIself) :: Pattern) ((_operatorIself) :: Name) ((_rangeIself) :: Range) ((_rightPatternIself) :: Pattern) ->
     LeftHandSide_Infix _rangeIself _leftPatternIself _operatorIself _rightPatternIself
   {-# INLINE rule2455 #-}
   rule2455 = \ _self ->
     _self
   {-# INLINE rule2456 #-}
   rule2456 = \ ((_rightPatternIbetaUnique) :: Int) ->
     _rightPatternIbetaUnique
   {-# INLINE rule2457 #-}
   rule2457 = \ _constraints ->
     _constraints
   {-# INLINE rule2458 #-}
   rule2458 = \ ((_rightPatternIcounter) :: Int) ->
     _rightPatternIcounter
   {-# INLINE rule2459 #-}
   rule2459 = \ ((_rightPatternIpatternMatchWarnings) :: [Warning]) ->
     _rightPatternIpatternMatchWarnings
   {-# INLINE rule2460 #-}
   rule2460 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2461 #-}
   rule2461 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2462 #-}
   rule2462 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2463 #-}
   rule2463 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2464 #-}
   rule2464 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2465 #-}
   rule2465 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2466 #-}
   rule2466 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2467 #-}
   rule2467 = \ ((_leftPatternIbetaUnique) :: Int) ->
     _leftPatternIbetaUnique
   {-# INLINE rule2468 #-}
   rule2468 = \ ((_leftPatternIcounter) :: Int) ->
     _leftPatternIcounter
   {-# INLINE rule2469 #-}
   rule2469 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2470 #-}
   rule2470 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2471 #-}
   rule2471 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2472 #-}
   rule2472 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2473 #-}
   rule2473 = \ ((_leftPatternIpatternMatchWarnings) :: [Warning]) ->
     _leftPatternIpatternMatchWarnings
{-# NOINLINE sem_LeftHandSide_Parenthesized #-}
sem_LeftHandSide_Parenthesized :: T_Range  -> T_LeftHandSide  -> T_Patterns  -> T_LeftHandSide 
sem_LeftHandSide_Parenthesized arg_range_ arg_lefthandside_ arg_patterns_ = T_LeftHandSide (return st83) where
   {-# NOINLINE st83 #-}
   st83 = let
      v82 :: T_LeftHandSide_v82 
      v82 = \ (T_LeftHandSide_vIn82 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _lefthandsideX83 = Control.Monad.Identity.runIdentity (attach_T_LeftHandSide (arg_lefthandside_))
         _patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_LeftHandSide_vOut82 _lefthandsideIargcount _lefthandsideIbetaUnique _lefthandsideIbetas _lefthandsideIconstraints _lefthandsideIcounter _lefthandsideIelements _lefthandsideIenvironment _lefthandsideIinfoTrees _lefthandsideIname _lefthandsideInumberOfPatterns _lefthandsideIpatVarNames _lefthandsideIpatternMatchWarnings _lefthandsideIself _lefthandsideIunboundNames) = inv_LeftHandSide_s83 _lefthandsideX83 (T_LeftHandSide_vIn82 _lefthandsideObetaUnique _lefthandsideOcounter _lefthandsideOimportEnvironment _lefthandsideOmonos _lefthandsideOnamesInScope _lefthandsideOparentTree _lefthandsideOpatternMatchWarnings)
         (T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule2474 _lefthandsideInumberOfPatterns _patternsInumberOfPatterns
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2475 _lefthandsideIenvironment _patternsIenvironment
         _lhsObetas :: Tps
         _lhsObetas = rule2476 _lefthandsideIbetas _patternsIbetas
         _constraints = rule2477 _lefthandsideIconstraints _patternsIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2478 _lefthandsideIinfoTrees _patternsIinfoTrees
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2479 _lefthandsideIpatVarNames _patternsIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2480 _lefthandsideIunboundNames _patternsIunboundNames
         _self = rule2481 _lefthandsideIself _patternsIself _rangeIself
         _lhsOself :: LeftHandSide
         _lhsOself = rule2482 _self
         _lhsOargcount :: Int
         _lhsOargcount = rule2483 _lefthandsideIargcount
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2484 _patternsIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2485 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2486 _patternsIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2487 _lefthandsideIelements
         _lhsOname :: Name
         _lhsOname = rule2488 _lefthandsideIname
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2489 _patternsIpatternMatchWarnings
         _lefthandsideObetaUnique = rule2490 _lhsIbetaUnique
         _lefthandsideOcounter = rule2491 _lhsIcounter
         _lefthandsideOimportEnvironment = rule2492 _lhsIimportEnvironment
         _lefthandsideOmonos = rule2493 _lhsImonos
         _lefthandsideOnamesInScope = rule2494 _lhsInamesInScope
         _lefthandsideOparentTree = rule2495 _lhsIparentTree
         _lefthandsideOpatternMatchWarnings = rule2496 _lhsIpatternMatchWarnings
         _patternsObetaUnique = rule2497 _lefthandsideIbetaUnique
         _patternsOcounter = rule2498 _lefthandsideIcounter
         _patternsOimportEnvironment = rule2499 _lhsIimportEnvironment
         _patternsOmonos = rule2500 _lhsImonos
         _patternsOnamesInScope = rule2501 _lhsInamesInScope
         _patternsOparentTree = rule2502 _lhsIparentTree
         _patternsOpatternMatchWarnings = rule2503 _lefthandsideIpatternMatchWarnings
         __result_ = T_LeftHandSide_vOut82 _lhsOargcount _lhsObetaUnique _lhsObetas _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTrees _lhsOname _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_LeftHandSide_s83 v82
   {-# INLINE rule2474 #-}
   rule2474 = \ ((_lefthandsideInumberOfPatterns) :: Int) ((_patternsInumberOfPatterns) :: Int) ->
                                 _lefthandsideInumberOfPatterns + _patternsInumberOfPatterns
   {-# INLINE rule2475 #-}
   rule2475 = \ ((_lefthandsideIenvironment) :: PatternAssumptions) ((_patternsIenvironment) :: PatternAssumptions) ->
                                 _lefthandsideIenvironment `M.union` _patternsIenvironment
   {-# INLINE rule2476 #-}
   rule2476 = \ ((_lefthandsideIbetas) :: Tps) ((_patternsIbetas) :: Tps) ->
                                 _lefthandsideIbetas ++ _patternsIbetas
   {-# INLINE rule2477 #-}
   rule2477 = \ ((_lefthandsideIconstraints) :: ConstraintSet) ((_patternsIconstraintslist) :: ConstraintSets) ->
                                 Node ( _lefthandsideIconstraints : _patternsIconstraintslist )
   {-# INLINE rule2478 #-}
   rule2478 = \ ((_lefthandsideIinfoTrees) :: InfoTrees) ((_patternsIinfoTrees) :: InfoTrees) ->
                                       _lefthandsideIinfoTrees ++ _patternsIinfoTrees
   {-# INLINE rule2479 #-}
   rule2479 = \ ((_lefthandsideIpatVarNames) :: Names) ((_patternsIpatVarNames) :: Names) ->
     _lefthandsideIpatVarNames ++ _patternsIpatVarNames
   {-# INLINE rule2480 #-}
   rule2480 = \ ((_lefthandsideIunboundNames) :: Names) ((_patternsIunboundNames) :: Names) ->
     _lefthandsideIunboundNames ++ _patternsIunboundNames
   {-# INLINE rule2481 #-}
   rule2481 = \ ((_lefthandsideIself) :: LeftHandSide) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
     LeftHandSide_Parenthesized _rangeIself _lefthandsideIself _patternsIself
   {-# INLINE rule2482 #-}
   rule2482 = \ _self ->
     _self
   {-# INLINE rule2483 #-}
   rule2483 = \ ((_lefthandsideIargcount) :: Int) ->
     _lefthandsideIargcount
   {-# INLINE rule2484 #-}
   rule2484 = \ ((_patternsIbetaUnique) :: Int) ->
     _patternsIbetaUnique
   {-# INLINE rule2485 #-}
   rule2485 = \ _constraints ->
     _constraints
   {-# INLINE rule2486 #-}
   rule2486 = \ ((_patternsIcounter) :: Int) ->
     _patternsIcounter
   {-# INLINE rule2487 #-}
   rule2487 = \ ((_lefthandsideIelements) ::   [PatternElement]        ) ->
     _lefthandsideIelements
   {-# INLINE rule2488 #-}
   rule2488 = \ ((_lefthandsideIname) :: Name) ->
     _lefthandsideIname
   {-# INLINE rule2489 #-}
   rule2489 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
     _patternsIpatternMatchWarnings
   {-# INLINE rule2490 #-}
   rule2490 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2491 #-}
   rule2491 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2492 #-}
   rule2492 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2493 #-}
   rule2493 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2494 #-}
   rule2494 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2495 #-}
   rule2495 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2496 #-}
   rule2496 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2497 #-}
   rule2497 = \ ((_lefthandsideIbetaUnique) :: Int) ->
     _lefthandsideIbetaUnique
   {-# INLINE rule2498 #-}
   rule2498 = \ ((_lefthandsideIcounter) :: Int) ->
     _lefthandsideIcounter
   {-# INLINE rule2499 #-}
   rule2499 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2500 #-}
   rule2500 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2501 #-}
   rule2501 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2502 #-}
   rule2502 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2503 #-}
   rule2503 = \ ((_lefthandsideIpatternMatchWarnings) :: [Warning]) ->
     _lefthandsideIpatternMatchWarnings

-- Literal -----------------------------------------------------
-- wrapper
data Inh_Literal  = Inh_Literal {  }
data Syn_Literal  = Syn_Literal { elements_Syn_Literal :: (  [PatternElement]        ), literalType_Syn_Literal :: (Tp), self_Syn_Literal :: (Literal) }
{-# INLINABLE wrap_Literal #-}
wrap_Literal :: T_Literal  -> Inh_Literal  -> (Syn_Literal )
wrap_Literal (T_Literal act) (Inh_Literal ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Literal_vIn85 
        (T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself) <- return (inv_Literal_s86 sem arg)
        return (Syn_Literal _lhsOelements _lhsOliteralType _lhsOself)
   )

-- cata
{-# NOINLINE sem_Literal #-}
sem_Literal :: Literal  -> T_Literal 
sem_Literal ( Literal_Int range_ value_ ) = sem_Literal_Int ( sem_Range range_ ) value_
sem_Literal ( Literal_Char range_ value_ ) = sem_Literal_Char ( sem_Range range_ ) value_
sem_Literal ( Literal_Float range_ value_ ) = sem_Literal_Float ( sem_Range range_ ) value_
sem_Literal ( Literal_String range_ value_ ) = sem_Literal_String ( sem_Range range_ ) value_

-- semantic domain
newtype T_Literal  = T_Literal {
                               attach_T_Literal :: Identity (T_Literal_s86 )
                               }
newtype T_Literal_s86  = C_Literal_s86 {
                                       inv_Literal_s86 :: (T_Literal_v85 )
                                       }
data T_Literal_s87  = C_Literal_s87
type T_Literal_v85  = (T_Literal_vIn85 ) -> (T_Literal_vOut85 )
data T_Literal_vIn85  = T_Literal_vIn85 
data T_Literal_vOut85  = T_Literal_vOut85 (  [PatternElement]        ) (Tp) (Literal)
{-# NOINLINE sem_Literal_Int #-}
sem_Literal_Int :: T_Range  -> (String) -> T_Literal 
sem_Literal_Int arg_range_ arg_value_ = T_Literal (return st86) where
   {-# NOINLINE st86 #-}
   st86 = let
      v85 :: T_Literal_v85 
      v85 = \ (T_Literal_vIn85 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOliteralType :: Tp
         _lhsOliteralType = rule2504  ()
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2505 arg_value_
         _self = rule2506 _rangeIself arg_value_
         _lhsOself :: Literal
         _lhsOself = rule2507 _self
         __result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
         in __result_ )
     in C_Literal_s86 v85
   {-# INLINE rule2504 #-}
   rule2504 = \  (_ :: ()) ->
                                  intType
   {-# INLINE rule2505 #-}
   rule2505 = \ value_ ->
                                         [InfiniteElement value_]
   {-# INLINE rule2506 #-}
   rule2506 = \ ((_rangeIself) :: Range) value_ ->
     Literal_Int _rangeIself value_
   {-# INLINE rule2507 #-}
   rule2507 = \ _self ->
     _self
{-# NOINLINE sem_Literal_Char #-}
sem_Literal_Char :: T_Range  -> (String) -> T_Literal 
sem_Literal_Char arg_range_ arg_value_ = T_Literal (return st86) where
   {-# NOINLINE st86 #-}
   st86 = let
      v85 :: T_Literal_v85 
      v85 = \ (T_Literal_vIn85 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOliteralType :: Tp
         _lhsOliteralType = rule2508  ()
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2509 arg_value_
         _self = rule2510 _rangeIself arg_value_
         _lhsOself :: Literal
         _lhsOself = rule2511 _self
         __result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
         in __result_ )
     in C_Literal_s86 v85
   {-# INLINE rule2508 #-}
   rule2508 = \  (_ :: ()) ->
                                  charType
   {-# INLINE rule2509 #-}
   rule2509 = \ value_ ->
                                         [InfiniteElement value_]
   {-# INLINE rule2510 #-}
   rule2510 = \ ((_rangeIself) :: Range) value_ ->
     Literal_Char _rangeIself value_
   {-# INLINE rule2511 #-}
   rule2511 = \ _self ->
     _self
{-# NOINLINE sem_Literal_Float #-}
sem_Literal_Float :: T_Range  -> (String) -> T_Literal 
sem_Literal_Float arg_range_ arg_value_ = T_Literal (return st86) where
   {-# NOINLINE st86 #-}
   st86 = let
      v85 :: T_Literal_v85 
      v85 = \ (T_Literal_vIn85 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOliteralType :: Tp
         _lhsOliteralType = rule2512  ()
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2513 arg_value_
         _self = rule2514 _rangeIself arg_value_
         _lhsOself :: Literal
         _lhsOself = rule2515 _self
         __result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
         in __result_ )
     in C_Literal_s86 v85
   {-# INLINE rule2512 #-}
   rule2512 = \  (_ :: ()) ->
                                  floatType
   {-# INLINE rule2513 #-}
   rule2513 = \ value_ ->
                                         [InfiniteElement value_]
   {-# INLINE rule2514 #-}
   rule2514 = \ ((_rangeIself) :: Range) value_ ->
     Literal_Float _rangeIself value_
   {-# INLINE rule2515 #-}
   rule2515 = \ _self ->
     _self
{-# NOINLINE sem_Literal_String #-}
sem_Literal_String :: T_Range  -> (String) -> T_Literal 
sem_Literal_String arg_range_ arg_value_ = T_Literal (return st86) where
   {-# NOINLINE st86 #-}
   st86 = let
      v85 :: T_Literal_v85 
      v85 = \ (T_Literal_vIn85 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsOliteralType :: Tp
         _lhsOliteralType = rule2516  ()
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2517 arg_value_
         _self = rule2518 _rangeIself arg_value_
         _lhsOself :: Literal
         _lhsOself = rule2519 _self
         __result_ = T_Literal_vOut85 _lhsOelements _lhsOliteralType _lhsOself
         in __result_ )
     in C_Literal_s86 v85
   {-# INLINE rule2516 #-}
   rule2516 = \  (_ :: ()) ->
                                  stringType
   {-# INLINE rule2517 #-}
   rule2517 = \ value_ ->
                                         stringPat value_
   {-# INLINE rule2518 #-}
   rule2518 = \ ((_rangeIself) :: Range) value_ ->
     Literal_String _rangeIself value_
   {-# INLINE rule2519 #-}
   rule2519 = \ _self ->
     _self

-- MaybeDeclarations -------------------------------------------
-- wrapper
data Inh_MaybeDeclarations  = Inh_MaybeDeclarations { allPatterns_Inh_MaybeDeclarations :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_MaybeDeclarations :: (M.Map NameWithRange TpScheme), assumptions_Inh_MaybeDeclarations :: (Assumptions), availablePredicates_Inh_MaybeDeclarations :: (Predicates), betaUnique_Inh_MaybeDeclarations :: (Int), classEnvironment_Inh_MaybeDeclarations :: (ClassEnvironment), collectErrors_Inh_MaybeDeclarations :: (TypeErrors), collectWarnings_Inh_MaybeDeclarations :: (Warnings), constraints_Inh_MaybeDeclarations :: (ConstraintSet), counter_Inh_MaybeDeclarations :: (Int), currentChunk_Inh_MaybeDeclarations :: (Int), dictionaryEnvironment_Inh_MaybeDeclarations :: (DictionaryEnvironment), importEnvironment_Inh_MaybeDeclarations :: (ImportEnvironment), matchIO_Inh_MaybeDeclarations :: (IO ()), monos_Inh_MaybeDeclarations :: (Monos), namesInScope_Inh_MaybeDeclarations :: (Names), orderedTypeSynonyms_Inh_MaybeDeclarations :: (OrderedTypeSynonyms), parentTree_Inh_MaybeDeclarations :: (InfoTree), patternMatchWarnings_Inh_MaybeDeclarations :: ([Warning]), substitution_Inh_MaybeDeclarations :: (FixpointSubstitution), typeschemeMap_Inh_MaybeDeclarations :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_MaybeDeclarations :: (Names), uniqueChunk_Inh_MaybeDeclarations :: (Int) }
data Syn_MaybeDeclarations  = Syn_MaybeDeclarations { assumptions_Syn_MaybeDeclarations :: (Assumptions), betaUnique_Syn_MaybeDeclarations :: (Int), collectErrors_Syn_MaybeDeclarations :: (TypeErrors), collectInstances_Syn_MaybeDeclarations :: ([(Name, Instance)]), collectWarnings_Syn_MaybeDeclarations :: (Warnings), constraints_Syn_MaybeDeclarations :: (ConstraintSet), counter_Syn_MaybeDeclarations :: (Int), dictionaryEnvironment_Syn_MaybeDeclarations :: (DictionaryEnvironment), infoTrees_Syn_MaybeDeclarations :: (InfoTrees), localTypes_Syn_MaybeDeclarations :: (M.Map NameWithRange TpScheme), matchIO_Syn_MaybeDeclarations :: (IO ()), namesInScope_Syn_MaybeDeclarations :: (Names), patternMatchWarnings_Syn_MaybeDeclarations :: ([Warning]), self_Syn_MaybeDeclarations :: (MaybeDeclarations), unboundNames_Syn_MaybeDeclarations :: (Names), uniqueChunk_Syn_MaybeDeclarations :: (Int) }
{-# INLINABLE wrap_MaybeDeclarations #-}
wrap_MaybeDeclarations :: T_MaybeDeclarations  -> Inh_MaybeDeclarations  -> (Syn_MaybeDeclarations )
wrap_MaybeDeclarations (T_MaybeDeclarations act) (Inh_MaybeDeclarations _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeDeclarations_vIn88 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk
        (T_MaybeDeclarations_vOut88 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_MaybeDeclarations_s89 sem arg)
        return (Syn_MaybeDeclarations _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_MaybeDeclarations #-}
sem_MaybeDeclarations :: MaybeDeclarations  -> T_MaybeDeclarations 
sem_MaybeDeclarations ( MaybeDeclarations_Nothing  ) = sem_MaybeDeclarations_Nothing 
sem_MaybeDeclarations ( MaybeDeclarations_Just declarations_ ) = sem_MaybeDeclarations_Just ( sem_Declarations declarations_ )

-- semantic domain
newtype T_MaybeDeclarations  = T_MaybeDeclarations {
                                                   attach_T_MaybeDeclarations :: Identity (T_MaybeDeclarations_s89 )
                                                   }
newtype T_MaybeDeclarations_s89  = C_MaybeDeclarations_s89 {
                                                           inv_MaybeDeclarations_s89 :: (T_MaybeDeclarations_v88 )
                                                           }
data T_MaybeDeclarations_s90  = C_MaybeDeclarations_s90
type T_MaybeDeclarations_v88  = (T_MaybeDeclarations_vIn88 ) -> (T_MaybeDeclarations_vOut88 )
data T_MaybeDeclarations_vIn88  = T_MaybeDeclarations_vIn88 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int)
data T_MaybeDeclarations_vOut88  = T_MaybeDeclarations_vOut88 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTrees) (M.Map NameWithRange TpScheme) (IO ()) (Names) ([Warning]) (MaybeDeclarations) (Names) (Int)
{-# NOINLINE sem_MaybeDeclarations_Nothing #-}
sem_MaybeDeclarations_Nothing ::  T_MaybeDeclarations 
sem_MaybeDeclarations_Nothing  = T_MaybeDeclarations (return st89) where
   {-# NOINLINE st89 #-}
   st89 = let
      v88 :: T_MaybeDeclarations_v88 
      v88 = \ (T_MaybeDeclarations_vIn88 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk) -> ( let
         _lhsOlocalTypes :: M.Map NameWithRange TpScheme
         _lhsOlocalTypes = rule2520  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2521  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2522  ()
         _self = rule2523  ()
         _lhsOself :: MaybeDeclarations
         _lhsOself = rule2524 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2525 _lhsIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2526 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2527 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2528 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2529 _lhsIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2530 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2531 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2532 _lhsImatchIO
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule2533 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2534 _lhsIpatternMatchWarnings
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2535 _lhsIunboundNames
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2536 _lhsIuniqueChunk
         __result_ = T_MaybeDeclarations_vOut88 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_MaybeDeclarations_s89 v88
   {-# INLINE rule2520 #-}
   rule2520 = \  (_ :: ()) ->
                                   M.empty
   {-# INLINE rule2521 #-}
   rule2521 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule2522 #-}
   rule2522 = \  (_ :: ()) ->
     []
   {-# INLINE rule2523 #-}
   rule2523 = \  (_ :: ()) ->
     MaybeDeclarations_Nothing
   {-# INLINE rule2524 #-}
   rule2524 = \ _self ->
     _self
   {-# INLINE rule2525 #-}
   rule2525 = \ ((_lhsIassumptions) :: Assumptions) ->
     _lhsIassumptions
   {-# INLINE rule2526 #-}
   rule2526 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2527 #-}
   rule2527 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2528 #-}
   rule2528 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2529 #-}
   rule2529 = \ ((_lhsIconstraints) :: ConstraintSet) ->
     _lhsIconstraints
   {-# INLINE rule2530 #-}
   rule2530 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2531 #-}
   rule2531 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2532 #-}
   rule2532 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2533 #-}
   rule2533 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2534 #-}
   rule2534 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2535 #-}
   rule2535 = \ ((_lhsIunboundNames) :: Names) ->
     _lhsIunboundNames
   {-# INLINE rule2536 #-}
   rule2536 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_MaybeDeclarations_Just #-}
sem_MaybeDeclarations_Just :: T_Declarations  -> T_MaybeDeclarations 
sem_MaybeDeclarations_Just arg_declarations_ = T_MaybeDeclarations (return st89) where
   {-# NOINLINE st89 #-}
   st89 = let
      v88 :: T_MaybeDeclarations_v88 
      v88 = \ (T_MaybeDeclarations_vIn88 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk) -> ( let
         _declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
         (T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
         _declarationsObindingGroups = rule2537  ()
         _lhsOassumptions :: Assumptions
         _lhsOconstraints :: ConstraintSet
         _lhsObetaUnique :: Int
         (_lhsOassumptions,_lhsOconstraints,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule2538 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIassumptions _lhsIconstraints _lhsIcurrentChunk _lhsImonos
         _inferredTypes = rule2539 _implicitsFM _lhsItypeschemeMap
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2540 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2541 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
         _lhsOlocalTypes :: M.Map NameWithRange TpScheme
         _lhsOlocalTypes = rule2542 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
         _declarationsOtypeSignatures = rule2543  ()
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2544 _chunkNr
         _declInfo = rule2545 _declarationsIself _lhsImonos
         _theNode = rule2546 _declInfo _declarationsIinfoTrees _lhsIparentTree
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2547 _theNode
         _declarationsOparentTree = rule2548 _theNode
         (_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule2549  ()
         (_namesInScope,_unboundNames,_scopeInfo) = rule2550 _declarationsIdeclVarNames _declarationsIunboundNames _lhsInamesInScope _lhsIunboundNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2551 _unboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2552 _declarationsIcollectInstances
         _self = rule2553 _declarationsIself
         _lhsOself :: MaybeDeclarations
         _lhsOself = rule2554 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule2555 _declarationsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2556 _declarationsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2557 _declarationsImatchIO
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule2558 _namesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2559 _declarationsIpatternMatchWarnings
         _declarationsOallPatterns = rule2560 _lhsIallPatterns
         _declarationsOallTypeSchemes = rule2561 _lhsIallTypeSchemes
         _declarationsOavailablePredicates = rule2562 _lhsIavailablePredicates
         _declarationsObetaUnique = rule2563 _lhsIbetaUnique
         _declarationsOclassEnvironment = rule2564 _lhsIclassEnvironment
         _declarationsOcollectErrors = rule2565 _lhsIcollectErrors
         _declarationsOcollectWarnings = rule2566 _lhsIcollectWarnings
         _declarationsOcounter = rule2567 _lhsIcounter
         _declarationsOcurrentChunk = rule2568 _lhsIcurrentChunk
         _declarationsOdictionaryEnvironment = rule2569 _lhsIdictionaryEnvironment
         _declarationsOimportEnvironment = rule2570 _lhsIimportEnvironment
         _declarationsOinheritedBDG = rule2571 _inheritedBDG
         _declarationsOmatchIO = rule2572 _lhsImatchIO
         _declarationsOmonos = rule2573 _lhsImonos
         _declarationsOnamesInScope = rule2574 _namesInScope
         _declarationsOorderedTypeSynonyms = rule2575 _lhsIorderedTypeSynonyms
         _declarationsOpatternMatchWarnings = rule2576 _lhsIpatternMatchWarnings
         _declarationsOsubstitution = rule2577 _lhsIsubstitution
         _declarationsOtypeschemeMap = rule2578 _lhsItypeschemeMap
         _declarationsOuniqueChunk = rule2579 _lhsIuniqueChunk
         __result_ = T_MaybeDeclarations_vOut88 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOlocalTypes _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_MaybeDeclarations_s89 v88
   {-# INLINE rule2537 #-}
   rule2537 = \  (_ :: ()) ->
                                        []
   {-# INLINE rule2538 #-}
   rule2538 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIassumptions) :: Assumptions) ((_lhsIconstraints) :: ConstraintSet) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
           let inputBDG   = (False, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _declarationsIbetaUnique)
               mybdggroup = Just (_lhsIassumptions, [_lhsIconstraints])
           in performBindingGroup inputBDG _declarationsIbindingGroups
   {-# INLINE rule2539 #-}
   rule2539 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
                                        findInferredTypes _lhsItypeschemeMap _implicitsFM
   {-# INLINE rule2540 #-}
   rule2540 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
                                        missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
                                        ++ _declarationsIcollectWarnings
   {-# INLINE rule2541 #-}
   rule2541 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
                                        restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
                                        ++ _declarationsIcollectErrors
   {-# INLINE rule2542 #-}
   rule2542 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
                                   makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
   {-# INLINE rule2543 #-}
   rule2543 = \  (_ :: ()) ->
                                                                  M.empty
   {-# INLINE rule2544 #-}
   rule2544 = \ _chunkNr ->
                                                     _chunkNr
   {-# INLINE rule2545 #-}
   rule2545 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
                          LocalInfo { self = UHA_Decls _declarationsIself
                                    , assignedType = Nothing
                                    , monos = _lhsImonos
                                    }
   {-# INLINE rule2546 #-}
   rule2546 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) ->
                                 node _lhsIparentTree _declInfo _declarationsIinfoTrees
   {-# INLINE rule2547 #-}
   rule2547 = \ _theNode ->
                                 [_theNode]
   {-# INLINE rule2548 #-}
   rule2548 = \ _theNode ->
                                           _theNode
   {-# INLINE rule2549 #-}
   rule2549 = \  (_ :: ()) ->
                                                                                                                                                   internalError "PartialSyntax.ag" "n/a" "toplevel MaybeDeclaration"
   {-# INLINE rule2550 #-}
   rule2550 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ->
                                                               changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
   {-# INLINE rule2551 #-}
   rule2551 = \ _unboundNames ->
                                  _unboundNames
   {-# INLINE rule2552 #-}
   rule2552 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
     _declarationsIcollectInstances
   {-# INLINE rule2553 #-}
   rule2553 = \ ((_declarationsIself) :: Declarations) ->
     MaybeDeclarations_Just _declarationsIself
   {-# INLINE rule2554 #-}
   rule2554 = \ _self ->
     _self
   {-# INLINE rule2555 #-}
   rule2555 = \ ((_declarationsIcounter) :: Int) ->
     _declarationsIcounter
   {-# INLINE rule2556 #-}
   rule2556 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _declarationsIdictionaryEnvironment
   {-# INLINE rule2557 #-}
   rule2557 = \ ((_declarationsImatchIO) :: IO ()) ->
     _declarationsImatchIO
   {-# INLINE rule2558 #-}
   rule2558 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule2559 #-}
   rule2559 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
     _declarationsIpatternMatchWarnings
   {-# INLINE rule2560 #-}
   rule2560 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2561 #-}
   rule2561 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2562 #-}
   rule2562 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2563 #-}
   rule2563 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2564 #-}
   rule2564 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2565 #-}
   rule2565 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2566 #-}
   rule2566 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2567 #-}
   rule2567 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2568 #-}
   rule2568 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2569 #-}
   rule2569 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2570 #-}
   rule2570 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2571 #-}
   rule2571 = \ _inheritedBDG ->
     _inheritedBDG
   {-# INLINE rule2572 #-}
   rule2572 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2573 #-}
   rule2573 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2574 #-}
   rule2574 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule2575 #-}
   rule2575 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2576 #-}
   rule2576 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2577 #-}
   rule2577 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2578 #-}
   rule2578 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2579 #-}
   rule2579 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- MaybeExports ------------------------------------------------
-- wrapper
data Inh_MaybeExports  = Inh_MaybeExports {  }
data Syn_MaybeExports  = Syn_MaybeExports { self_Syn_MaybeExports :: (MaybeExports) }
{-# INLINABLE wrap_MaybeExports #-}
wrap_MaybeExports :: T_MaybeExports  -> Inh_MaybeExports  -> (Syn_MaybeExports )
wrap_MaybeExports (T_MaybeExports act) (Inh_MaybeExports ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeExports_vIn91 
        (T_MaybeExports_vOut91 _lhsOself) <- return (inv_MaybeExports_s92 sem arg)
        return (Syn_MaybeExports _lhsOself)
   )

-- cata
{-# NOINLINE sem_MaybeExports #-}
sem_MaybeExports :: MaybeExports  -> T_MaybeExports 
sem_MaybeExports ( MaybeExports_Nothing  ) = sem_MaybeExports_Nothing 
sem_MaybeExports ( MaybeExports_Just exports_ ) = sem_MaybeExports_Just ( sem_Exports exports_ )

-- semantic domain
newtype T_MaybeExports  = T_MaybeExports {
                                         attach_T_MaybeExports :: Identity (T_MaybeExports_s92 )
                                         }
newtype T_MaybeExports_s92  = C_MaybeExports_s92 {
                                                 inv_MaybeExports_s92 :: (T_MaybeExports_v91 )
                                                 }
data T_MaybeExports_s93  = C_MaybeExports_s93
type T_MaybeExports_v91  = (T_MaybeExports_vIn91 ) -> (T_MaybeExports_vOut91 )
data T_MaybeExports_vIn91  = T_MaybeExports_vIn91 
data T_MaybeExports_vOut91  = T_MaybeExports_vOut91 (MaybeExports)
{-# NOINLINE sem_MaybeExports_Nothing #-}
sem_MaybeExports_Nothing ::  T_MaybeExports 
sem_MaybeExports_Nothing  = T_MaybeExports (return st92) where
   {-# NOINLINE st92 #-}
   st92 = let
      v91 :: T_MaybeExports_v91 
      v91 = \ (T_MaybeExports_vIn91 ) -> ( let
         _self = rule2580  ()
         _lhsOself :: MaybeExports
         _lhsOself = rule2581 _self
         __result_ = T_MaybeExports_vOut91 _lhsOself
         in __result_ )
     in C_MaybeExports_s92 v91
   {-# INLINE rule2580 #-}
   rule2580 = \  (_ :: ()) ->
     MaybeExports_Nothing
   {-# INLINE rule2581 #-}
   rule2581 = \ _self ->
     _self
{-# NOINLINE sem_MaybeExports_Just #-}
sem_MaybeExports_Just :: T_Exports  -> T_MaybeExports 
sem_MaybeExports_Just arg_exports_ = T_MaybeExports (return st92) where
   {-# NOINLINE st92 #-}
   st92 = let
      v91 :: T_MaybeExports_v91 
      v91 = \ (T_MaybeExports_vIn91 ) -> ( let
         _exportsX38 = Control.Monad.Identity.runIdentity (attach_T_Exports (arg_exports_))
         (T_Exports_vOut37 _exportsIself) = inv_Exports_s38 _exportsX38 (T_Exports_vIn37 )
         _self = rule2582 _exportsIself
         _lhsOself :: MaybeExports
         _lhsOself = rule2583 _self
         __result_ = T_MaybeExports_vOut91 _lhsOself
         in __result_ )
     in C_MaybeExports_s92 v91
   {-# INLINE rule2582 #-}
   rule2582 = \ ((_exportsIself) :: Exports) ->
     MaybeExports_Just _exportsIself
   {-# INLINE rule2583 #-}
   rule2583 = \ _self ->
     _self

-- MaybeExpression ---------------------------------------------
-- wrapper
data Inh_MaybeExpression  = Inh_MaybeExpression { allPatterns_Inh_MaybeExpression :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_MaybeExpression :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_MaybeExpression :: (Predicates), betaUnique_Inh_MaybeExpression :: (Int), classEnvironment_Inh_MaybeExpression :: (ClassEnvironment), collectErrors_Inh_MaybeExpression :: (TypeErrors), collectWarnings_Inh_MaybeExpression :: (Warnings), counter_Inh_MaybeExpression :: (Int), currentChunk_Inh_MaybeExpression :: (Int), dictionaryEnvironment_Inh_MaybeExpression :: (DictionaryEnvironment), importEnvironment_Inh_MaybeExpression :: (ImportEnvironment), matchIO_Inh_MaybeExpression :: (IO ()), monos_Inh_MaybeExpression :: (Monos), namesInScope_Inh_MaybeExpression :: (Names), orderedTypeSynonyms_Inh_MaybeExpression :: (OrderedTypeSynonyms), parentTree_Inh_MaybeExpression :: (InfoTree), patternMatchWarnings_Inh_MaybeExpression :: ([Warning]), substitution_Inh_MaybeExpression :: (FixpointSubstitution), tryPatterns_Inh_MaybeExpression :: ([(MaybeExpression, [String])]), typeschemeMap_Inh_MaybeExpression :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_MaybeExpression :: (Int), uniqueSecondRound_Inh_MaybeExpression :: (Int) }
data Syn_MaybeExpression  = Syn_MaybeExpression { assumptions_Syn_MaybeExpression :: (Assumptions), beta_Syn_MaybeExpression :: (Tp), betaUnique_Syn_MaybeExpression :: (Int), collectErrors_Syn_MaybeExpression :: (TypeErrors), collectInstances_Syn_MaybeExpression :: ([(Name, Instance)]), collectWarnings_Syn_MaybeExpression :: (Warnings), constraints_Syn_MaybeExpression :: (ConstraintSet), counter_Syn_MaybeExpression :: (Int), dictionaryEnvironment_Syn_MaybeExpression :: (DictionaryEnvironment), infoTrees_Syn_MaybeExpression :: (InfoTrees), matchIO_Syn_MaybeExpression :: (IO ()), matches_Syn_MaybeExpression :: ([Maybe MetaVariableTable]), patternMatchWarnings_Syn_MaybeExpression :: ([Warning]), section_Syn_MaybeExpression :: (Bool), self_Syn_MaybeExpression :: (MaybeExpression), unboundNames_Syn_MaybeExpression :: (Names), uniqueChunk_Syn_MaybeExpression :: (Int), uniqueSecondRound_Syn_MaybeExpression :: (Int) }
{-# INLINABLE wrap_MaybeExpression #-}
wrap_MaybeExpression :: T_MaybeExpression  -> Inh_MaybeExpression  -> (Syn_MaybeExpression )
wrap_MaybeExpression (T_MaybeExpression act) (Inh_MaybeExpression _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeExpression_vIn94 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_MaybeExpression_vOut94 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_MaybeExpression_s95 sem arg)
        return (Syn_MaybeExpression _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_MaybeExpression #-}
sem_MaybeExpression :: MaybeExpression  -> T_MaybeExpression 
sem_MaybeExpression ( MaybeExpression_Nothing  ) = sem_MaybeExpression_Nothing 
sem_MaybeExpression ( MaybeExpression_Just expression_ ) = sem_MaybeExpression_Just ( sem_Expression expression_ )

-- semantic domain
newtype T_MaybeExpression  = T_MaybeExpression {
                                               attach_T_MaybeExpression :: Identity (T_MaybeExpression_s95 )
                                               }
newtype T_MaybeExpression_s95  = C_MaybeExpression_s95 {
                                                       inv_MaybeExpression_s95 :: (T_MaybeExpression_v94 )
                                                       }
data T_MaybeExpression_s96  = C_MaybeExpression_s96
type T_MaybeExpression_v94  = (T_MaybeExpression_vIn94 ) -> (T_MaybeExpression_vOut94 )
data T_MaybeExpression_vIn94  = T_MaybeExpression_vIn94 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) ([(MaybeExpression, [String])]) (M.Map Int (Scheme Predicates)) (Int) (Int)
data T_MaybeExpression_vOut94  = T_MaybeExpression_vOut94 (Assumptions) (Tp) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTrees) (IO ()) ([Maybe MetaVariableTable]) ([Warning]) (Bool) (MaybeExpression) (Names) (Int) (Int)
{-# NOINLINE sem_MaybeExpression_Nothing #-}
sem_MaybeExpression_Nothing ::  T_MaybeExpression 
sem_MaybeExpression_Nothing  = T_MaybeExpression (return st95) where
   {-# NOINLINE st95 #-}
   st95 = let
      v94 :: T_MaybeExpression_v94 
      v94 = \ (T_MaybeExpression_vIn94 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _lhsOsection :: Bool
         _lhsOsection = rule2584  ()
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2585 _lhsIbetaUnique
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2586  ()
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2587  ()
         _beta = rule2588 _lhsIbetaUnique
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2589  ()
         _lhsOmatches :: [Maybe MetaVariableTable]
         ((),_lhsOmatches,_,_,_,_) = rule2590 _lhsItryPatterns
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2591  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2592  ()
         _self = rule2593  ()
         _lhsOself :: MaybeExpression
         _lhsOself = rule2594 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2595 _beta
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2596 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2597 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule2598 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2599 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2600 _lhsImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2601 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2602 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule2603 _lhsIuniqueSecondRound
         __result_ = T_MaybeExpression_vOut94 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_MaybeExpression_s95 v94
   {-# INLINE rule2584 #-}
   rule2584 = \  (_ :: ()) ->
                            True
   {-# INLINE rule2585 #-}
   rule2585 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule2586 #-}
   rule2586 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule2587 #-}
   rule2587 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule2588 #-}
   rule2588 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule2589 #-}
   rule2589 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule2590 #-}
   rule2590 = \ ((_lhsItryPatterns) :: [(MaybeExpression, [String])]) ->
            match0' match_MaybeExpression_Nothing _lhsItryPatterns [] []
   {-# INLINE rule2591 #-}
   rule2591 = \  (_ :: ()) ->
     []
   {-# INLINE rule2592 #-}
   rule2592 = \  (_ :: ()) ->
     []
   {-# INLINE rule2593 #-}
   rule2593 = \  (_ :: ()) ->
     MaybeExpression_Nothing
   {-# INLINE rule2594 #-}
   rule2594 = \ _self ->
     _self
   {-# INLINE rule2595 #-}
   rule2595 = \ _beta ->
     _beta
   {-# INLINE rule2596 #-}
   rule2596 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2597 #-}
   rule2597 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2598 #-}
   rule2598 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2599 #-}
   rule2599 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2600 #-}
   rule2600 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2601 #-}
   rule2601 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2602 #-}
   rule2602 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2603 #-}
   rule2603 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_MaybeExpression_Just #-}
sem_MaybeExpression_Just :: T_Expression  -> T_MaybeExpression 
sem_MaybeExpression_Just arg_expression_ = T_MaybeExpression (return st95) where
   {-# NOINLINE st95 #-}
   st95 = let
      v94 :: T_MaybeExpression_v94 
      v94 = \ (T_MaybeExpression_vIn94 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItryPatterns _lhsItypeschemeMap _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOsection :: Bool
         _lhsOsection = rule2604  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule2605 _expressionIinfoTree
         _lhsOmatches :: [Maybe MetaVariableTable]
         (_expressionOtryPatterns,_lhsOmatches,_,_,_,_) = rule2606 _expressionImatches _lhsItryPatterns
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule2607 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2608 _expressionIunboundNames
         _self = rule2609 _expressionIself
         _lhsOself :: MaybeExpression
         _lhsOself = rule2610 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2611 _expressionIassumptions
         _lhsObeta :: Tp
         _lhsObeta = rule2612 _expressionIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2613 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule2614 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule2615 _expressionIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2616 _expressionIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2617 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2618 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule2619 _expressionImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2620 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule2621 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule2622 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule2623 _lhsIallPatterns
         _expressionOallTypeSchemes = rule2624 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule2625 _lhsIavailablePredicates
         _expressionObetaUnique = rule2626 _lhsIbetaUnique
         _expressionOclassEnvironment = rule2627 _lhsIclassEnvironment
         _expressionOcollectErrors = rule2628 _lhsIcollectErrors
         _expressionOcollectWarnings = rule2629 _lhsIcollectWarnings
         _expressionOcounter = rule2630 _lhsIcounter
         _expressionOcurrentChunk = rule2631 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule2632 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule2633 _lhsIimportEnvironment
         _expressionOmatchIO = rule2634 _lhsImatchIO
         _expressionOmonos = rule2635 _lhsImonos
         _expressionOnamesInScope = rule2636 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule2637 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule2638 _lhsIparentTree
         _expressionOpatternMatchWarnings = rule2639 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule2640 _lhsIsubstitution
         _expressionOtypeschemeMap = rule2641 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule2642 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule2643 _lhsIuniqueSecondRound
         __result_ = T_MaybeExpression_vOut94 _lhsOassumptions _lhsObeta _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmatches _lhsOpatternMatchWarnings _lhsOsection _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_MaybeExpression_s95 v94
   {-# INLINE rule2604 #-}
   rule2604 = \  (_ :: ()) ->
                        False
   {-# INLINE rule2605 #-}
   rule2605 = \ ((_expressionIinfoTree) :: InfoTree) ->
                                 [_expressionIinfoTree]
   {-# INLINE rule2606 #-}
   rule2606 = \ ((_expressionImatches) :: [Maybe MetaVariableTable]) ((_lhsItryPatterns) :: [(MaybeExpression, [String])]) ->
            match1' match_MaybeExpression_Just _lhsItryPatterns [] [_expressionImatches]
   {-# INLINE rule2607 #-}
   rule2607 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule2608 #-}
   rule2608 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule2609 #-}
   rule2609 = \ ((_expressionIself) :: Expression) ->
     MaybeExpression_Just _expressionIself
   {-# INLINE rule2610 #-}
   rule2610 = \ _self ->
     _self
   {-# INLINE rule2611 #-}
   rule2611 = \ ((_expressionIassumptions) :: Assumptions) ->
     _expressionIassumptions
   {-# INLINE rule2612 #-}
   rule2612 = \ ((_expressionIbeta) :: Tp) ->
     _expressionIbeta
   {-# INLINE rule2613 #-}
   rule2613 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule2614 #-}
   rule2614 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule2615 #-}
   rule2615 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule2616 #-}
   rule2616 = \ ((_expressionIconstraints) :: ConstraintSet) ->
     _expressionIconstraints
   {-# INLINE rule2617 #-}
   rule2617 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule2618 #-}
   rule2618 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule2619 #-}
   rule2619 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule2620 #-}
   rule2620 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule2621 #-}
   rule2621 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule2622 #-}
   rule2622 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule2623 #-}
   rule2623 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule2624 #-}
   rule2624 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule2625 #-}
   rule2625 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule2626 #-}
   rule2626 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2627 #-}
   rule2627 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule2628 #-}
   rule2628 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule2629 #-}
   rule2629 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule2630 #-}
   rule2630 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2631 #-}
   rule2631 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule2632 #-}
   rule2632 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule2633 #-}
   rule2633 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2634 #-}
   rule2634 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule2635 #-}
   rule2635 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2636 #-}
   rule2636 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2637 #-}
   rule2637 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule2638 #-}
   rule2638 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2639 #-}
   rule2639 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2640 #-}
   rule2640 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule2641 #-}
   rule2641 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule2642 #-}
   rule2642 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule2643 #-}
   rule2643 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- MaybeImportSpecification ------------------------------------
-- wrapper
data Inh_MaybeImportSpecification  = Inh_MaybeImportSpecification {  }
data Syn_MaybeImportSpecification  = Syn_MaybeImportSpecification { self_Syn_MaybeImportSpecification :: (MaybeImportSpecification) }
{-# INLINABLE wrap_MaybeImportSpecification #-}
wrap_MaybeImportSpecification :: T_MaybeImportSpecification  -> Inh_MaybeImportSpecification  -> (Syn_MaybeImportSpecification )
wrap_MaybeImportSpecification (T_MaybeImportSpecification act) (Inh_MaybeImportSpecification ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeImportSpecification_vIn97 
        (T_MaybeImportSpecification_vOut97 _lhsOself) <- return (inv_MaybeImportSpecification_s98 sem arg)
        return (Syn_MaybeImportSpecification _lhsOself)
   )

-- cata
{-# NOINLINE sem_MaybeImportSpecification #-}
sem_MaybeImportSpecification :: MaybeImportSpecification  -> T_MaybeImportSpecification 
sem_MaybeImportSpecification ( MaybeImportSpecification_Nothing  ) = sem_MaybeImportSpecification_Nothing 
sem_MaybeImportSpecification ( MaybeImportSpecification_Just importspecification_ ) = sem_MaybeImportSpecification_Just ( sem_ImportSpecification importspecification_ )

-- semantic domain
newtype T_MaybeImportSpecification  = T_MaybeImportSpecification {
                                                                 attach_T_MaybeImportSpecification :: Identity (T_MaybeImportSpecification_s98 )
                                                                 }
newtype T_MaybeImportSpecification_s98  = C_MaybeImportSpecification_s98 {
                                                                         inv_MaybeImportSpecification_s98 :: (T_MaybeImportSpecification_v97 )
                                                                         }
data T_MaybeImportSpecification_s99  = C_MaybeImportSpecification_s99
type T_MaybeImportSpecification_v97  = (T_MaybeImportSpecification_vIn97 ) -> (T_MaybeImportSpecification_vOut97 )
data T_MaybeImportSpecification_vIn97  = T_MaybeImportSpecification_vIn97 
data T_MaybeImportSpecification_vOut97  = T_MaybeImportSpecification_vOut97 (MaybeImportSpecification)
{-# NOINLINE sem_MaybeImportSpecification_Nothing #-}
sem_MaybeImportSpecification_Nothing ::  T_MaybeImportSpecification 
sem_MaybeImportSpecification_Nothing  = T_MaybeImportSpecification (return st98) where
   {-# NOINLINE st98 #-}
   st98 = let
      v97 :: T_MaybeImportSpecification_v97 
      v97 = \ (T_MaybeImportSpecification_vIn97 ) -> ( let
         _self = rule2644  ()
         _lhsOself :: MaybeImportSpecification
         _lhsOself = rule2645 _self
         __result_ = T_MaybeImportSpecification_vOut97 _lhsOself
         in __result_ )
     in C_MaybeImportSpecification_s98 v97
   {-# INLINE rule2644 #-}
   rule2644 = \  (_ :: ()) ->
     MaybeImportSpecification_Nothing
   {-# INLINE rule2645 #-}
   rule2645 = \ _self ->
     _self
{-# NOINLINE sem_MaybeImportSpecification_Just #-}
sem_MaybeImportSpecification_Just :: T_ImportSpecification  -> T_MaybeImportSpecification 
sem_MaybeImportSpecification_Just arg_importspecification_ = T_MaybeImportSpecification (return st98) where
   {-# NOINLINE st98 #-}
   st98 = let
      v97 :: T_MaybeImportSpecification_v97 
      v97 = \ (T_MaybeImportSpecification_vIn97 ) -> ( let
         _importspecificationX77 = Control.Monad.Identity.runIdentity (attach_T_ImportSpecification (arg_importspecification_))
         (T_ImportSpecification_vOut76 _importspecificationIself) = inv_ImportSpecification_s77 _importspecificationX77 (T_ImportSpecification_vIn76 )
         _self = rule2646 _importspecificationIself
         _lhsOself :: MaybeImportSpecification
         _lhsOself = rule2647 _self
         __result_ = T_MaybeImportSpecification_vOut97 _lhsOself
         in __result_ )
     in C_MaybeImportSpecification_s98 v97
   {-# INLINE rule2646 #-}
   rule2646 = \ ((_importspecificationIself) :: ImportSpecification) ->
     MaybeImportSpecification_Just _importspecificationIself
   {-# INLINE rule2647 #-}
   rule2647 = \ _self ->
     _self

-- MaybeInt ----------------------------------------------------
-- wrapper
data Inh_MaybeInt  = Inh_MaybeInt {  }
data Syn_MaybeInt  = Syn_MaybeInt { self_Syn_MaybeInt :: (MaybeInt) }
{-# INLINABLE wrap_MaybeInt #-}
wrap_MaybeInt :: T_MaybeInt  -> Inh_MaybeInt  -> (Syn_MaybeInt )
wrap_MaybeInt (T_MaybeInt act) (Inh_MaybeInt ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeInt_vIn100 
        (T_MaybeInt_vOut100 _lhsOself) <- return (inv_MaybeInt_s101 sem arg)
        return (Syn_MaybeInt _lhsOself)
   )

-- cata
{-# NOINLINE sem_MaybeInt #-}
sem_MaybeInt :: MaybeInt  -> T_MaybeInt 
sem_MaybeInt ( MaybeInt_Nothing  ) = sem_MaybeInt_Nothing 
sem_MaybeInt ( MaybeInt_Just int_ ) = sem_MaybeInt_Just int_

-- semantic domain
newtype T_MaybeInt  = T_MaybeInt {
                                 attach_T_MaybeInt :: Identity (T_MaybeInt_s101 )
                                 }
newtype T_MaybeInt_s101  = C_MaybeInt_s101 {
                                           inv_MaybeInt_s101 :: (T_MaybeInt_v100 )
                                           }
data T_MaybeInt_s102  = C_MaybeInt_s102
type T_MaybeInt_v100  = (T_MaybeInt_vIn100 ) -> (T_MaybeInt_vOut100 )
data T_MaybeInt_vIn100  = T_MaybeInt_vIn100 
data T_MaybeInt_vOut100  = T_MaybeInt_vOut100 (MaybeInt)
{-# NOINLINE sem_MaybeInt_Nothing #-}
sem_MaybeInt_Nothing ::  T_MaybeInt 
sem_MaybeInt_Nothing  = T_MaybeInt (return st101) where
   {-# NOINLINE st101 #-}
   st101 = let
      v100 :: T_MaybeInt_v100 
      v100 = \ (T_MaybeInt_vIn100 ) -> ( let
         _self = rule2648  ()
         _lhsOself :: MaybeInt
         _lhsOself = rule2649 _self
         __result_ = T_MaybeInt_vOut100 _lhsOself
         in __result_ )
     in C_MaybeInt_s101 v100
   {-# INLINE rule2648 #-}
   rule2648 = \  (_ :: ()) ->
     MaybeInt_Nothing
   {-# INLINE rule2649 #-}
   rule2649 = \ _self ->
     _self
{-# NOINLINE sem_MaybeInt_Just #-}
sem_MaybeInt_Just :: (Int) -> T_MaybeInt 
sem_MaybeInt_Just arg_int_ = T_MaybeInt (return st101) where
   {-# NOINLINE st101 #-}
   st101 = let
      v100 :: T_MaybeInt_v100 
      v100 = \ (T_MaybeInt_vIn100 ) -> ( let
         _self = rule2650 arg_int_
         _lhsOself :: MaybeInt
         _lhsOself = rule2651 _self
         __result_ = T_MaybeInt_vOut100 _lhsOself
         in __result_ )
     in C_MaybeInt_s101 v100
   {-# INLINE rule2650 #-}
   rule2650 = \ int_ ->
     MaybeInt_Just int_
   {-# INLINE rule2651 #-}
   rule2651 = \ _self ->
     _self

-- MaybeName ---------------------------------------------------
-- wrapper
data Inh_MaybeName  = Inh_MaybeName {  }
data Syn_MaybeName  = Syn_MaybeName { self_Syn_MaybeName :: (MaybeName) }
{-# INLINABLE wrap_MaybeName #-}
wrap_MaybeName :: T_MaybeName  -> Inh_MaybeName  -> (Syn_MaybeName )
wrap_MaybeName (T_MaybeName act) (Inh_MaybeName ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeName_vIn103 
        (T_MaybeName_vOut103 _lhsOself) <- return (inv_MaybeName_s104 sem arg)
        return (Syn_MaybeName _lhsOself)
   )

-- cata
{-# NOINLINE sem_MaybeName #-}
sem_MaybeName :: MaybeName  -> T_MaybeName 
sem_MaybeName ( MaybeName_Nothing  ) = sem_MaybeName_Nothing 
sem_MaybeName ( MaybeName_Just name_ ) = sem_MaybeName_Just ( sem_Name name_ )

-- semantic domain
newtype T_MaybeName  = T_MaybeName {
                                   attach_T_MaybeName :: Identity (T_MaybeName_s104 )
                                   }
newtype T_MaybeName_s104  = C_MaybeName_s104 {
                                             inv_MaybeName_s104 :: (T_MaybeName_v103 )
                                             }
data T_MaybeName_s105  = C_MaybeName_s105
type T_MaybeName_v103  = (T_MaybeName_vIn103 ) -> (T_MaybeName_vOut103 )
data T_MaybeName_vIn103  = T_MaybeName_vIn103 
data T_MaybeName_vOut103  = T_MaybeName_vOut103 (MaybeName)
{-# NOINLINE sem_MaybeName_Nothing #-}
sem_MaybeName_Nothing ::  T_MaybeName 
sem_MaybeName_Nothing  = T_MaybeName (return st104) where
   {-# NOINLINE st104 #-}
   st104 = let
      v103 :: T_MaybeName_v103 
      v103 = \ (T_MaybeName_vIn103 ) -> ( let
         _self = rule2652  ()
         _lhsOself :: MaybeName
         _lhsOself = rule2653 _self
         __result_ = T_MaybeName_vOut103 _lhsOself
         in __result_ )
     in C_MaybeName_s104 v103
   {-# INLINE rule2652 #-}
   rule2652 = \  (_ :: ()) ->
     MaybeName_Nothing
   {-# INLINE rule2653 #-}
   rule2653 = \ _self ->
     _self
{-# NOINLINE sem_MaybeName_Just #-}
sem_MaybeName_Just :: T_Name  -> T_MaybeName 
sem_MaybeName_Just arg_name_ = T_MaybeName (return st104) where
   {-# NOINLINE st104 #-}
   st104 = let
      v103 :: T_MaybeName_v103 
      v103 = \ (T_MaybeName_vIn103 ) -> ( let
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule2654 _nameIself
         _lhsOself :: MaybeName
         _lhsOself = rule2655 _self
         __result_ = T_MaybeName_vOut103 _lhsOself
         in __result_ )
     in C_MaybeName_s104 v103
   {-# INLINE rule2654 #-}
   rule2654 = \ ((_nameIself) :: Name) ->
     MaybeName_Just _nameIself
   {-# INLINE rule2655 #-}
   rule2655 = \ _self ->
     _self

-- MaybeNames --------------------------------------------------
-- wrapper
data Inh_MaybeNames  = Inh_MaybeNames {  }
data Syn_MaybeNames  = Syn_MaybeNames { self_Syn_MaybeNames :: (MaybeNames) }
{-# INLINABLE wrap_MaybeNames #-}
wrap_MaybeNames :: T_MaybeNames  -> Inh_MaybeNames  -> (Syn_MaybeNames )
wrap_MaybeNames (T_MaybeNames act) (Inh_MaybeNames ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_MaybeNames_vIn106 
        (T_MaybeNames_vOut106 _lhsOself) <- return (inv_MaybeNames_s107 sem arg)
        return (Syn_MaybeNames _lhsOself)
   )

-- cata
{-# NOINLINE sem_MaybeNames #-}
sem_MaybeNames :: MaybeNames  -> T_MaybeNames 
sem_MaybeNames ( MaybeNames_Nothing  ) = sem_MaybeNames_Nothing 
sem_MaybeNames ( MaybeNames_Just names_ ) = sem_MaybeNames_Just ( sem_Names names_ )

-- semantic domain
newtype T_MaybeNames  = T_MaybeNames {
                                     attach_T_MaybeNames :: Identity (T_MaybeNames_s107 )
                                     }
newtype T_MaybeNames_s107  = C_MaybeNames_s107 {
                                               inv_MaybeNames_s107 :: (T_MaybeNames_v106 )
                                               }
data T_MaybeNames_s108  = C_MaybeNames_s108
type T_MaybeNames_v106  = (T_MaybeNames_vIn106 ) -> (T_MaybeNames_vOut106 )
data T_MaybeNames_vIn106  = T_MaybeNames_vIn106 
data T_MaybeNames_vOut106  = T_MaybeNames_vOut106 (MaybeNames)
{-# NOINLINE sem_MaybeNames_Nothing #-}
sem_MaybeNames_Nothing ::  T_MaybeNames 
sem_MaybeNames_Nothing  = T_MaybeNames (return st107) where
   {-# NOINLINE st107 #-}
   st107 = let
      v106 :: T_MaybeNames_v106 
      v106 = \ (T_MaybeNames_vIn106 ) -> ( let
         _self = rule2656  ()
         _lhsOself :: MaybeNames
         _lhsOself = rule2657 _self
         __result_ = T_MaybeNames_vOut106 _lhsOself
         in __result_ )
     in C_MaybeNames_s107 v106
   {-# INLINE rule2656 #-}
   rule2656 = \  (_ :: ()) ->
     MaybeNames_Nothing
   {-# INLINE rule2657 #-}
   rule2657 = \ _self ->
     _self
{-# NOINLINE sem_MaybeNames_Just #-}
sem_MaybeNames_Just :: T_Names  -> T_MaybeNames 
sem_MaybeNames_Just arg_names_ = T_MaybeNames (return st107) where
   {-# NOINLINE st107 #-}
   st107 = let
      v106 :: T_MaybeNames_v106 
      v106 = \ (T_MaybeNames_vIn106 ) -> ( let
         _namesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_names_))
         (T_Names_vOut115 _namesIself) = inv_Names_s116 _namesX116 (T_Names_vIn115 )
         _self = rule2658 _namesIself
         _lhsOself :: MaybeNames
         _lhsOself = rule2659 _self
         __result_ = T_MaybeNames_vOut106 _lhsOself
         in __result_ )
     in C_MaybeNames_s107 v106
   {-# INLINE rule2658 #-}
   rule2658 = \ ((_namesIself) :: Names) ->
     MaybeNames_Just _namesIself
   {-# INLINE rule2659 #-}
   rule2659 = \ _self ->
     _self

-- Module ------------------------------------------------------
-- wrapper
data Inh_Module  = Inh_Module { importEnvironment_Inh_Module :: (ImportEnvironment), options_Inh_Module :: ([Option]) }
data Syn_Module  = Syn_Module { assumptions_Syn_Module :: (Assumptions), dictionaryEnvironment_Syn_Module :: (DictionaryEnvironment), infoTree_Syn_Module :: (InfoTree), logEntries_Syn_Module :: (LogEntries), self_Syn_Module :: (Module), solveResult_Syn_Module :: (SolveResult ConstraintInfo), toplevelTypes_Syn_Module :: (TypeEnvironment), typeErrors_Syn_Module :: (TypeErrors), warnings_Syn_Module :: (Warnings) }
{-# INLINABLE wrap_Module #-}
wrap_Module :: T_Module  -> Inh_Module  -> (Syn_Module )
wrap_Module (T_Module act) (Inh_Module _lhsIimportEnvironment _lhsIoptions) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Module_vIn109 _lhsIimportEnvironment _lhsIoptions
        (T_Module_vOut109 _lhsOassumptions _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOlogEntries _lhsOself _lhsOsolveResult _lhsOtoplevelTypes _lhsOtypeErrors _lhsOwarnings) <- return (inv_Module_s110 sem arg)
        return (Syn_Module _lhsOassumptions _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOlogEntries _lhsOself _lhsOsolveResult _lhsOtoplevelTypes _lhsOtypeErrors _lhsOwarnings)
   )

-- cata
{-# INLINE sem_Module #-}
sem_Module :: Module  -> T_Module 
sem_Module ( Module_Module range_ name_ exports_ body_ ) = sem_Module_Module ( sem_Range range_ ) ( sem_MaybeName name_ ) ( sem_MaybeExports exports_ ) ( sem_Body body_ )

-- semantic domain
newtype T_Module  = T_Module {
                             attach_T_Module :: Identity (T_Module_s110 )
                             }
newtype T_Module_s110  = C_Module_s110 {
                                       inv_Module_s110 :: (T_Module_v109 )
                                       }
data T_Module_s111  = C_Module_s111
type T_Module_v109  = (T_Module_vIn109 ) -> (T_Module_vOut109 )
data T_Module_vIn109  = T_Module_vIn109 (ImportEnvironment) ([Option])
data T_Module_vOut109  = T_Module_vOut109 (Assumptions) (DictionaryEnvironment) (InfoTree) (LogEntries) (Module) (SolveResult ConstraintInfo) (TypeEnvironment) (TypeErrors) (Warnings)
{-# NOINLINE sem_Module_Module #-}
sem_Module_Module :: T_Range  -> T_MaybeName  -> T_MaybeExports  -> T_Body  -> T_Module 
sem_Module_Module arg_range_ arg_name_ arg_exports_ arg_body_ = T_Module (return st110) where
   {-# NOINLINE st110 #-}
   st110 = let
      v109 :: T_Module_v109 
      v109 = \ (T_Module_vIn109 _lhsIimportEnvironment _lhsIoptions) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX104 = Control.Monad.Identity.runIdentity (attach_T_MaybeName (arg_name_))
         _exportsX92 = Control.Monad.Identity.runIdentity (attach_T_MaybeExports (arg_exports_))
         _bodyX14 = Control.Monad.Identity.runIdentity (attach_T_Body (arg_body_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_MaybeName_vOut103 _nameIself) = inv_MaybeName_s104 _nameX104 (T_MaybeName_vIn103 )
         (T_MaybeExports_vOut91 _exportsIself) = inv_MaybeExports_s92 _exportsX92 (T_MaybeExports_vIn91 )
         (T_Body_vOut13 _bodyIassumptions _bodyIbetaUnique _bodyIcollectErrors _bodyIcollectInstances _bodyIcollectWarnings _bodyIconstraints _bodyIcounter _bodyIdeclVarNames _bodyIdictionaryEnvironment _bodyIinfoTree _bodyImatchIO _bodyIpatternMatchWarnings _bodyIself _bodyItoplevelTypes _bodyIunboundNames _bodyIuniqueChunk) = inv_Body_s14 _bodyX14 (T_Body_vIn13 _bodyOallPatterns _bodyOallTypeSchemes _bodyOavailablePredicates _bodyObetaUnique _bodyOclassEnvironment _bodyOcollectErrors _bodyOcollectWarnings _bodyOcounter _bodyOcurrentChunk _bodyOdictionaryEnvironment _bodyOimportEnvironment _bodyOmatchIO _bodyOmonos _bodyOnamesInScope _bodyOorderedTypeSynonyms _bodyOpatternMatchWarnings _bodyOsubstitution _bodyOtypeschemeMap _bodyOuniqueChunk)
         _lhsOwarnings :: Warnings
         _lhsOwarnings = rule2660 _bodyIpatternMatchWarnings _warnings
         (SolveResult _betaUniqueAtTheEnd _substitution _typeschemeMap _ _solveErrors) = rule2661 _solveResult
         (_solveResult,_logEntries) = rule2662 _bodyIbetaUnique _bodyIconstraints _classEnv _lhsIimportEnvironment _lhsIoptions _orderedTypeSynonyms
         _orderedTypeSynonyms = rule2663 _lhsIimportEnvironment
         _classEnv = rule2664 _bodyIcollectInstances _lhsIimportEnvironment
         _typeErrors = rule2665 _bodyIcollectErrors _classEnv _lhsIoptions _orderedTypeSynonyms _solveErrors _substitution
         _warnings = rule2666 _bodyIcollectWarnings
         _assumptions = rule2667 _bodyIassumptions _substitution
         _initialScope = rule2668 _lhsIimportEnvironment
         _monos = rule2669 _monomorphics
         _monomorphics = rule2670 _lhsIimportEnvironment
         _bodyOtypeschemeMap = rule2671 _typeschemeMap
         _bodyObetaUnique = rule2672 _monomorphics
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule2673 _bodyIdictionaryEnvironment _lhsIoptions
         _bodyOdictionaryEnvironment = rule2674  ()
         _bodyOclassEnvironment = rule2675 _classEnv
         _bodyOavailablePredicates = rule2676  ()
         _bodyOcollectWarnings = rule2677  ()
         _bodyOcollectErrors = rule2678  ()
         _bodyOallTypeSchemes = rule2679 _lhsIimportEnvironment
         _bodyOcurrentChunk = rule2680  ()
         _bodyOuniqueChunk = rule2681  ()
         (_namesInScope,_unboundNames,_scopeInfo) = rule2682 _bodyIdeclVarNames _bodyIunboundNames _initialScope
         _bodyOcounter = rule2683  ()
         _bodyOmatchIO = rule2684  ()
         _bodyOallPatterns = rule2685 _lhsIimportEnvironment
         _bodyOpatternMatchWarnings = rule2686  ()
         _self = rule2687 _bodyIself _exportsIself _nameIself _rangeIself
         _lhsOself :: Module
         _lhsOself = rule2688 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule2689 _assumptions
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2690 _bodyIinfoTree
         _lhsOlogEntries :: LogEntries
         _lhsOlogEntries = rule2691 _logEntries
         _lhsOsolveResult :: SolveResult ConstraintInfo
         _lhsOsolveResult = rule2692 _solveResult
         _lhsOtoplevelTypes :: TypeEnvironment
         _lhsOtoplevelTypes = rule2693 _bodyItoplevelTypes
         _lhsOtypeErrors :: TypeErrors
         _lhsOtypeErrors = rule2694 _typeErrors
         _bodyOimportEnvironment = rule2695 _lhsIimportEnvironment
         _bodyOmonos = rule2696 _monos
         _bodyOnamesInScope = rule2697 _namesInScope
         _bodyOorderedTypeSynonyms = rule2698 _orderedTypeSynonyms
         _bodyOsubstitution = rule2699 _substitution
         __result_ = T_Module_vOut109 _lhsOassumptions _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOlogEntries _lhsOself _lhsOsolveResult _lhsOtoplevelTypes _lhsOtypeErrors _lhsOwarnings
         in __result_ )
     in C_Module_s110 v109
   {-# INLINE rule2660 #-}
   rule2660 = \ ((_bodyIpatternMatchWarnings) :: [Warning]) _warnings ->
                              _warnings     ++ _bodyIpatternMatchWarnings
   {-# INLINE rule2661 #-}
   rule2661 = \ _solveResult ->
                                                                                           _solveResult
   {-# INLINE rule2662 #-}
   rule2662 = \ ((_bodyIbetaUnique) :: Int) ((_bodyIconstraints) :: ConstraintSet) _classEnv ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIoptions) :: [Option]) _orderedTypeSynonyms ->
                  (selectConstraintSolver _lhsIoptions _lhsIimportEnvironment)
                     _classEnv
                     _orderedTypeSynonyms
                     _bodyIbetaUnique
                     _bodyIconstraints
   {-# INLINE rule2663 #-}
   rule2663 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                     getOrderedTypeSynonyms _lhsIimportEnvironment
   {-# INLINE rule2664 #-}
   rule2664 = \ ((_bodyIcollectInstances) :: [(Name, Instance)]) ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                     foldr (\(n, i) -> insertInstance (show n) i)
                                           (createClassEnvironment _lhsIimportEnvironment)
                                           _bodyIcollectInstances
   {-# INLINE rule2665 #-}
   rule2665 = \ ((_bodyIcollectErrors) :: TypeErrors) _classEnv ((_lhsIoptions) :: [Option]) _orderedTypeSynonyms _solveErrors _substitution ->
                                     case makeTypeErrors _lhsIoptions _classEnv _orderedTypeSynonyms _substitution _solveErrors of
                                        []   -> if NoOverloadingTypeCheck `elem` _lhsIoptions
                                                   then filter (\(TypeError _ ms _ _) -> not $ isInfixOf "Illegal overloaded type" $ show ms) _bodyIcollectErrors
                                                   else _bodyIcollectErrors
                                        errs -> reverse errs
   {-# INLINE rule2666 #-}
   rule2666 = \ ((_bodyIcollectWarnings) :: Warnings) ->
                                     _bodyIcollectWarnings
   {-# INLINE rule2667 #-}
   rule2667 = \ ((_bodyIassumptions) :: Assumptions) _substitution ->
                                     let f xs = [ (n, _substitution |-> tp) | (n, tp) <- xs ]
                                     in M.map f _bodyIassumptions
   {-# INLINE rule2668 #-}
   rule2668 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                     M.keys (typeEnvironment _lhsIimportEnvironment)
   {-# INLINE rule2669 #-}
   rule2669 = \ _monomorphics ->
                                     map TVar _monomorphics
   {-# INLINE rule2670 #-}
   rule2670 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                     ftv (  (M.elems $ valueConstructors _lhsIimportEnvironment)
                                         ++ (M.elems $ typeEnvironment   _lhsIimportEnvironment)
                                         )
   {-# INLINE rule2671 #-}
   rule2671 = \ _typeschemeMap ->
                               M.fromList (M.assocs _typeschemeMap)
   {-# INLINE rule2672 #-}
   rule2672 = \ _monomorphics ->
                                     if null _monomorphics
                                       then 0
                                       else maximum _monomorphics + 1
   {-# INLINE rule2673 #-}
   rule2673 = \ ((_bodyIdictionaryEnvironment) :: DictionaryEnvironment) ((_lhsIoptions) :: [Option]) ->
                                        if Overloading `elem` _lhsIoptions
                                          then _bodyIdictionaryEnvironment
                                          else emptyDictionaryEnvironment
   {-# INLINE rule2674 #-}
   rule2674 = \  (_ :: ()) ->
                                        emptyDictionaryEnvironment
   {-# INLINE rule2675 #-}
   rule2675 = \ _classEnv ->
                                        _classEnv
   {-# INLINE rule2676 #-}
   rule2676 = \  (_ :: ()) ->
                                        []
   {-# INLINE rule2677 #-}
   rule2677 = \  (_ :: ()) ->
                                       []
   {-# INLINE rule2678 #-}
   rule2678 = \  (_ :: ()) ->
                                       []
   {-# INLINE rule2679 #-}
   rule2679 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                      M.fromList [ (NameWithRange name, scheme) | (name, scheme) <- M.assocs (typeEnvironment _lhsIimportEnvironment) ]
   {-# INLINE rule2680 #-}
   rule2680 = \  (_ :: ()) ->
                                            0
   {-# INLINE rule2681 #-}
   rule2681 = \  (_ :: ()) ->
                                            1
   {-# INLINE rule2682 #-}
   rule2682 = \ ((_bodyIdeclVarNames) :: Names) ((_bodyIunboundNames) :: Names) _initialScope ->
                                                               changeOfScope (_initialScope ++ _bodyIdeclVarNames) _bodyIunboundNames []
   {-# INLINE rule2683 #-}
   rule2683 = \  (_ :: ()) ->
                                0
   {-# INLINE rule2684 #-}
   rule2684 = \  (_ :: ()) ->
                                        return ()
   {-# INLINE rule2685 #-}
   rule2685 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                              [ (matchInfo, typingStrategy)
                              | typingStrategy <- typingStrategies _lhsIimportEnvironment
                              , matchInfo      <- matchInformation
                                                   _lhsIimportEnvironment
                                                   typingStrategy
                              ]
   {-# INLINE rule2686 #-}
   rule2686 = \  (_ :: ()) ->
                                              []
   {-# INLINE rule2687 #-}
   rule2687 = \ ((_bodyIself) :: Body) ((_exportsIself) :: MaybeExports) ((_nameIself) :: MaybeName) ((_rangeIself) :: Range) ->
     Module_Module _rangeIself _nameIself _exportsIself _bodyIself
   {-# INLINE rule2688 #-}
   rule2688 = \ _self ->
     _self
   {-# INLINE rule2689 #-}
   rule2689 = \ _assumptions ->
     _assumptions
   {-# INLINE rule2690 #-}
   rule2690 = \ ((_bodyIinfoTree) :: InfoTree) ->
     _bodyIinfoTree
   {-# INLINE rule2691 #-}
   rule2691 = \ _logEntries ->
     _logEntries
   {-# INLINE rule2692 #-}
   rule2692 = \ _solveResult ->
     _solveResult
   {-# INLINE rule2693 #-}
   rule2693 = \ ((_bodyItoplevelTypes) :: TypeEnvironment) ->
     _bodyItoplevelTypes
   {-# INLINE rule2694 #-}
   rule2694 = \ _typeErrors ->
     _typeErrors
   {-# INLINE rule2695 #-}
   rule2695 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2696 #-}
   rule2696 = \ _monos ->
     _monos
   {-# INLINE rule2697 #-}
   rule2697 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule2698 #-}
   rule2698 = \ _orderedTypeSynonyms ->
     _orderedTypeSynonyms
   {-# INLINE rule2699 #-}
   rule2699 = \ _substitution ->
     _substitution

-- Name --------------------------------------------------------
-- wrapper
data Inh_Name  = Inh_Name {  }
data Syn_Name  = Syn_Name { self_Syn_Name :: (Name) }
{-# INLINABLE wrap_Name #-}
wrap_Name :: T_Name  -> Inh_Name  -> (Syn_Name )
wrap_Name (T_Name act) (Inh_Name ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Name_vIn112 
        (T_Name_vOut112 _lhsOself) <- return (inv_Name_s113 sem arg)
        return (Syn_Name _lhsOself)
   )

-- cata
{-# NOINLINE sem_Name #-}
sem_Name :: Name  -> T_Name 
sem_Name ( Name_Identifier range_ module_ name_ ) = sem_Name_Identifier ( sem_Range range_ ) ( sem_Strings module_ ) name_
sem_Name ( Name_Operator range_ module_ name_ ) = sem_Name_Operator ( sem_Range range_ ) ( sem_Strings module_ ) name_
sem_Name ( Name_Special range_ module_ name_ ) = sem_Name_Special ( sem_Range range_ ) ( sem_Strings module_ ) name_

-- semantic domain
newtype T_Name  = T_Name {
                         attach_T_Name :: Identity (T_Name_s113 )
                         }
newtype T_Name_s113  = C_Name_s113 {
                                   inv_Name_s113 :: (T_Name_v112 )
                                   }
data T_Name_s114  = C_Name_s114
type T_Name_v112  = (T_Name_vIn112 ) -> (T_Name_vOut112 )
data T_Name_vIn112  = T_Name_vIn112 
data T_Name_vOut112  = T_Name_vOut112 (Name)
{-# NOINLINE sem_Name_Identifier #-}
sem_Name_Identifier :: T_Range  -> T_Strings  -> (String) -> T_Name 
sem_Name_Identifier arg_range_ arg_module_ arg_name_ = T_Name (return st113) where
   {-# NOINLINE st113 #-}
   st113 = let
      v112 :: T_Name_v112 
      v112 = \ (T_Name_vIn112 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _moduleX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_module_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Strings_vOut160 _moduleIself) = inv_Strings_s161 _moduleX161 (T_Strings_vIn160 )
         _self = rule2700 _moduleIself _rangeIself arg_name_
         _lhsOself :: Name
         _lhsOself = rule2701 _self
         __result_ = T_Name_vOut112 _lhsOself
         in __result_ )
     in C_Name_s113 v112
   {-# INLINE rule2700 #-}
   rule2700 = \ ((_moduleIself) :: Strings) ((_rangeIself) :: Range) name_ ->
     Name_Identifier _rangeIself _moduleIself name_
   {-# INLINE rule2701 #-}
   rule2701 = \ _self ->
     _self
{-# NOINLINE sem_Name_Operator #-}
sem_Name_Operator :: T_Range  -> T_Strings  -> (String) -> T_Name 
sem_Name_Operator arg_range_ arg_module_ arg_name_ = T_Name (return st113) where
   {-# NOINLINE st113 #-}
   st113 = let
      v112 :: T_Name_v112 
      v112 = \ (T_Name_vIn112 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _moduleX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_module_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Strings_vOut160 _moduleIself) = inv_Strings_s161 _moduleX161 (T_Strings_vIn160 )
         _self = rule2702 _moduleIself _rangeIself arg_name_
         _lhsOself :: Name
         _lhsOself = rule2703 _self
         __result_ = T_Name_vOut112 _lhsOself
         in __result_ )
     in C_Name_s113 v112
   {-# INLINE rule2702 #-}
   rule2702 = \ ((_moduleIself) :: Strings) ((_rangeIself) :: Range) name_ ->
     Name_Operator _rangeIself _moduleIself name_
   {-# INLINE rule2703 #-}
   rule2703 = \ _self ->
     _self
{-# NOINLINE sem_Name_Special #-}
sem_Name_Special :: T_Range  -> T_Strings  -> (String) -> T_Name 
sem_Name_Special arg_range_ arg_module_ arg_name_ = T_Name (return st113) where
   {-# NOINLINE st113 #-}
   st113 = let
      v112 :: T_Name_v112 
      v112 = \ (T_Name_vIn112 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _moduleX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_module_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Strings_vOut160 _moduleIself) = inv_Strings_s161 _moduleX161 (T_Strings_vIn160 )
         _self = rule2704 _moduleIself _rangeIself arg_name_
         _lhsOself :: Name
         _lhsOself = rule2705 _self
         __result_ = T_Name_vOut112 _lhsOself
         in __result_ )
     in C_Name_s113 v112
   {-# INLINE rule2704 #-}
   rule2704 = \ ((_moduleIself) :: Strings) ((_rangeIself) :: Range) name_ ->
     Name_Special _rangeIself _moduleIself name_
   {-# INLINE rule2705 #-}
   rule2705 = \ _self ->
     _self

-- Names -------------------------------------------------------
-- wrapper
data Inh_Names  = Inh_Names {  }
data Syn_Names  = Syn_Names { self_Syn_Names :: (Names) }
{-# INLINABLE wrap_Names #-}
wrap_Names :: T_Names  -> Inh_Names  -> (Syn_Names )
wrap_Names (T_Names act) (Inh_Names ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Names_vIn115 
        (T_Names_vOut115 _lhsOself) <- return (inv_Names_s116 sem arg)
        return (Syn_Names _lhsOself)
   )

-- cata
{-# NOINLINE sem_Names #-}
sem_Names :: Names  -> T_Names 
sem_Names list = Prelude.foldr sem_Names_Cons sem_Names_Nil (Prelude.map sem_Name list)

-- semantic domain
newtype T_Names  = T_Names {
                           attach_T_Names :: Identity (T_Names_s116 )
                           }
newtype T_Names_s116  = C_Names_s116 {
                                     inv_Names_s116 :: (T_Names_v115 )
                                     }
data T_Names_s117  = C_Names_s117
type T_Names_v115  = (T_Names_vIn115 ) -> (T_Names_vOut115 )
data T_Names_vIn115  = T_Names_vIn115 
data T_Names_vOut115  = T_Names_vOut115 (Names)
{-# NOINLINE sem_Names_Cons #-}
sem_Names_Cons :: T_Name  -> T_Names  -> T_Names 
sem_Names_Cons arg_hd_ arg_tl_ = T_Names (return st116) where
   {-# NOINLINE st116 #-}
   st116 = let
      v115 :: T_Names_v115 
      v115 = \ (T_Names_vIn115 ) -> ( let
         _hdX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_hd_))
         _tlX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_tl_))
         (T_Name_vOut112 _hdIself) = inv_Name_s113 _hdX113 (T_Name_vIn112 )
         (T_Names_vOut115 _tlIself) = inv_Names_s116 _tlX116 (T_Names_vIn115 )
         _self = rule2706 _hdIself _tlIself
         _lhsOself :: Names
         _lhsOself = rule2707 _self
         __result_ = T_Names_vOut115 _lhsOself
         in __result_ )
     in C_Names_s116 v115
   {-# INLINE rule2706 #-}
   rule2706 = \ ((_hdIself) :: Name) ((_tlIself) :: Names) ->
     (:) _hdIself _tlIself
   {-# INLINE rule2707 #-}
   rule2707 = \ _self ->
     _self
{-# NOINLINE sem_Names_Nil #-}
sem_Names_Nil ::  T_Names 
sem_Names_Nil  = T_Names (return st116) where
   {-# NOINLINE st116 #-}
   st116 = let
      v115 :: T_Names_v115 
      v115 = \ (T_Names_vIn115 ) -> ( let
         _self = rule2708  ()
         _lhsOself :: Names
         _lhsOself = rule2709 _self
         __result_ = T_Names_vOut115 _lhsOself
         in __result_ )
     in C_Names_s116 v115
   {-# INLINE rule2708 #-}
   rule2708 = \  (_ :: ()) ->
     []
   {-# INLINE rule2709 #-}
   rule2709 = \ _self ->
     _self

-- Pattern -----------------------------------------------------
-- wrapper
data Inh_Pattern  = Inh_Pattern { betaUnique_Inh_Pattern :: (Int), counter_Inh_Pattern :: (Int), importEnvironment_Inh_Pattern :: (ImportEnvironment), monos_Inh_Pattern :: (Monos), namesInScope_Inh_Pattern :: (Names), parentTree_Inh_Pattern :: (InfoTree), patternMatchWarnings_Inh_Pattern :: ([Warning]) }
data Syn_Pattern  = Syn_Pattern { beta_Syn_Pattern :: (Tp), betaUnique_Syn_Pattern :: (Int), constraints_Syn_Pattern :: (ConstraintSet), counter_Syn_Pattern :: (Int), elements_Syn_Pattern :: (  [PatternElement]        ), environment_Syn_Pattern :: (PatternAssumptions), infoTree_Syn_Pattern :: (InfoTree), patVarNames_Syn_Pattern :: (Names), patternMatchWarnings_Syn_Pattern :: ([Warning]), self_Syn_Pattern :: (Pattern), unboundNames_Syn_Pattern :: (Names) }
{-# INLINABLE wrap_Pattern #-}
wrap_Pattern :: T_Pattern  -> Inh_Pattern  -> (Syn_Pattern )
wrap_Pattern (T_Pattern act) (Inh_Pattern _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings
        (T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_Pattern_s119 sem arg)
        return (Syn_Pattern _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_Pattern #-}
sem_Pattern :: Pattern  -> T_Pattern 
sem_Pattern ( Pattern_Hole range_ id_ ) = sem_Pattern_Hole ( sem_Range range_ ) id_
sem_Pattern ( Pattern_Literal range_ literal_ ) = sem_Pattern_Literal ( sem_Range range_ ) ( sem_Literal literal_ )
sem_Pattern ( Pattern_Variable range_ name_ ) = sem_Pattern_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Pattern ( Pattern_Constructor range_ name_ patterns_ ) = sem_Pattern_Constructor ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Patterns patterns_ )
sem_Pattern ( Pattern_Parenthesized range_ pattern_ ) = sem_Pattern_Parenthesized ( sem_Range range_ ) ( sem_Pattern pattern_ )
sem_Pattern ( Pattern_InfixConstructor range_ leftPattern_ constructorOperator_ rightPattern_ ) = sem_Pattern_InfixConstructor ( sem_Range range_ ) ( sem_Pattern leftPattern_ ) ( sem_Name constructorOperator_ ) ( sem_Pattern rightPattern_ )
sem_Pattern ( Pattern_List range_ patterns_ ) = sem_Pattern_List ( sem_Range range_ ) ( sem_Patterns patterns_ )
sem_Pattern ( Pattern_Tuple range_ patterns_ ) = sem_Pattern_Tuple ( sem_Range range_ ) ( sem_Patterns patterns_ )
sem_Pattern ( Pattern_Record range_ name_ recordPatternBindings_ ) = sem_Pattern_Record ( sem_Range range_ ) ( sem_Name name_ ) ( sem_RecordPatternBindings recordPatternBindings_ )
sem_Pattern ( Pattern_Negate range_ literal_ ) = sem_Pattern_Negate ( sem_Range range_ ) ( sem_Literal literal_ )
sem_Pattern ( Pattern_As range_ name_ pattern_ ) = sem_Pattern_As ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Pattern pattern_ )
sem_Pattern ( Pattern_Wildcard range_ ) = sem_Pattern_Wildcard ( sem_Range range_ )
sem_Pattern ( Pattern_Irrefutable range_ pattern_ ) = sem_Pattern_Irrefutable ( sem_Range range_ ) ( sem_Pattern pattern_ )
sem_Pattern ( Pattern_Successor range_ name_ literal_ ) = sem_Pattern_Successor ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Literal literal_ )
sem_Pattern ( Pattern_NegateFloat range_ literal_ ) = sem_Pattern_NegateFloat ( sem_Range range_ ) ( sem_Literal literal_ )

-- semantic domain
newtype T_Pattern  = T_Pattern {
                               attach_T_Pattern :: Identity (T_Pattern_s119 )
                               }
newtype T_Pattern_s119  = C_Pattern_s119 {
                                         inv_Pattern_s119 :: (T_Pattern_v118 )
                                         }
data T_Pattern_s120  = C_Pattern_s120
type T_Pattern_v118  = (T_Pattern_vIn118 ) -> (T_Pattern_vOut118 )
data T_Pattern_vIn118  = T_Pattern_vIn118 (Int) (Int) (ImportEnvironment) (Monos) (Names) (InfoTree) ([Warning])
data T_Pattern_vOut118  = T_Pattern_vOut118 (Tp) (Int) (ConstraintSet) (Int) (  [PatternElement]        ) (PatternAssumptions) (InfoTree) (Names) ([Warning]) (Pattern) (Names)
{-# NOINLINE sem_Pattern_Hole #-}
sem_Pattern_Hole :: T_Range  -> (Integer) -> T_Pattern 
sem_Pattern_Hole arg_range_ arg_id_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2710 _lhsIbetaUnique
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2711  ()
         _constraints = rule2712  ()
         _beta = rule2713 _lhsIbetaUnique
         _localInfo = rule2714 _beta _lhsImonos _self
         _parentTree = rule2715 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2716 _parentTree
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2717 _i
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2718  ()
         _lhsOcounter :: Int
         _i :: Int
         (_lhsOcounter,_i) = rule2719 _lhsIcounter
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2720  ()
         _self = rule2721 _rangeIself arg_id_
         _lhsOself :: Pattern
         _lhsOself = rule2722 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2723 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2724 _constraints
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2725 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2710 #-}
   rule2710 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule2711 #-}
   rule2711 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule2712 #-}
   rule2712 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule2713 #-}
   rule2713 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule2714 #-}
   rule2714 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2715 #-}
   rule2715 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule2716 #-}
   rule2716 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2717 #-}
   rule2717 = \ ((_i) :: Int) ->
                                     [ Name_Special noRange [] ("hole" ++ show _i    ) ]
   {-# INLINE rule2718 #-}
   rule2718 = \  (_ :: ()) ->
                                         [FiniteElement hole]
   {-# INLINE rule2719 #-}
   rule2719 = \ ((_lhsIcounter) :: Int) ->
     let __cont = _lhsIcounter in seq __cont ( case nextUnique __cont of { (__cont, i) -> (__cont,i)} )
   {-# INLINE rule2720 #-}
   rule2720 = \  (_ :: ()) ->
     []
   {-# INLINE rule2721 #-}
   rule2721 = \ ((_rangeIself) :: Range) id_ ->
     Pattern_Hole _rangeIself id_
   {-# INLINE rule2722 #-}
   rule2722 = \ _self ->
     _self
   {-# INLINE rule2723 #-}
   rule2723 = \ _beta ->
     _beta
   {-# INLINE rule2724 #-}
   rule2724 = \ _constraints ->
     _constraints
   {-# INLINE rule2725 #-}
   rule2725 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Literal #-}
sem_Pattern_Literal :: T_Range  -> T_Literal  -> T_Pattern 
sem_Pattern_Literal arg_range_ arg_literal_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2726 _lhsIbetaUnique
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2727  ()
         _constraints = rule2728 _beta _cinfo _literalIliteralType
         _beta = rule2729 _lhsIbetaUnique
         _cinfo = rule2730 _parentTree
         _localInfo = rule2731 _beta _lhsImonos _self
         _parentTree = rule2732 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2733 _parentTree
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2734  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2735  ()
         _self = rule2736 _literalIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2737 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2738 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2739 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2740 _lhsIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2741 _literalIelements
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2742 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2726 #-}
   rule2726 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule2727 #-}
   rule2727 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule2728 #-}
   rule2728 = \ _beta _cinfo ((_literalIliteralType) :: Tp) ->
                            unitTree ((_literalIliteralType .==. _beta) _cinfo)
   {-# INLINE rule2729 #-}
   rule2729 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule2730 #-}
   rule2730 = \ _parentTree ->
     resultConstraint "literal pattern" _parentTree
        [ FolkloreConstraint, HasTrustFactor 10.0 ]
   {-# INLINE rule2731 #-}
   rule2731 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2732 #-}
   rule2732 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule2733 #-}
   rule2733 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2734 #-}
   rule2734 = \  (_ :: ()) ->
     []
   {-# INLINE rule2735 #-}
   rule2735 = \  (_ :: ()) ->
     []
   {-# INLINE rule2736 #-}
   rule2736 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
     Pattern_Literal _rangeIself _literalIself
   {-# INLINE rule2737 #-}
   rule2737 = \ _self ->
     _self
   {-# INLINE rule2738 #-}
   rule2738 = \ _beta ->
     _beta
   {-# INLINE rule2739 #-}
   rule2739 = \ _constraints ->
     _constraints
   {-# INLINE rule2740 #-}
   rule2740 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2741 #-}
   rule2741 = \ ((_literalIelements) ::   [PatternElement]        ) ->
     _literalIelements
   {-# INLINE rule2742 #-}
   rule2742 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Variable #-}
sem_Pattern_Variable :: T_Range  -> T_Name  -> T_Pattern 
sem_Pattern_Variable arg_range_ arg_name_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2743 _lhsIbetaUnique
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2744 _beta _nameIself
         _constraints = rule2745 _lhsIbetaUnique
         _beta = rule2746 _lhsIbetaUnique
         _localInfo = rule2747 _beta _lhsImonos _self
         _parentTree = rule2748 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2749 _parentTree
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2750 _nameIself
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2751  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2752  ()
         _self = rule2753 _nameIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2754 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2755 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2756 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2757 _lhsIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2758 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2743 #-}
   rule2743 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule2744 #-}
   rule2744 = \ _beta ((_nameIself) :: Name) ->
                            M.singleton _nameIself _beta
   {-# INLINE rule2745 #-}
   rule2745 = \ ((_lhsIbetaUnique) :: Int) ->
                            Receive _lhsIbetaUnique
   {-# INLINE rule2746 #-}
   rule2746 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule2747 #-}
   rule2747 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2748 #-}
   rule2748 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule2749 #-}
   rule2749 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2750 #-}
   rule2750 = \ ((_nameIself) :: Name) ->
                                     [ _nameIself ]
   {-# INLINE rule2751 #-}
   rule2751 = \  (_ :: ()) ->
                                         [WildcardElement]
   {-# INLINE rule2752 #-}
   rule2752 = \  (_ :: ()) ->
     []
   {-# INLINE rule2753 #-}
   rule2753 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Pattern_Variable _rangeIself _nameIself
   {-# INLINE rule2754 #-}
   rule2754 = \ _self ->
     _self
   {-# INLINE rule2755 #-}
   rule2755 = \ _beta ->
     _beta
   {-# INLINE rule2756 #-}
   rule2756 = \ _constraints ->
     _constraints
   {-# INLINE rule2757 #-}
   rule2757 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2758 #-}
   rule2758 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Constructor #-}
sem_Pattern_Constructor :: T_Range  -> T_Name  -> T_Patterns  -> T_Pattern 
sem_Pattern_Constructor arg_range_ arg_name_ arg_patterns_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
         _patternsObetaUnique = rule2759 _lhsIbetaUnique
         _constraints = rule2760 _conApply _conConstructor _patternsIconstraintslist
         _beta = rule2761 _lhsIbetaUnique
         _betaCon = rule2762 _lhsIbetaUnique
         _conApply = rule2763 _beta _betaCon _cinfoApply _cinfoEmpty _patternsIbetas _patternsInumberOfPatterns
         _conConstructor = rule2764 _betaCon _cinfoConstructor _lhsIimportEnvironment _nameIself
         _cinfoConstructor = rule2765 _parentTree
         _cinfoApply = rule2766 _localInfo _nameIself _parentTree _patternsIinfoTrees
         _cinfoEmpty = rule2767 _parentTree
         _localInfo = rule2768 _beta _lhsImonos _self
         _parentTree = rule2769 _lhsIparentTree _localInfo _patternsIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2770 _parentTree
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2771 _nameIself _patternsIelementss
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2772 _patternsIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2773 _patternsIunboundNames
         _self = rule2774 _nameIself _patternsIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2775 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2776 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2777 _patternsIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2778 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2779 _patternsIcounter
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2780 _patternsIenvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2781 _patternsIpatternMatchWarnings
         _patternsOcounter = rule2782 _lhsIcounter
         _patternsOimportEnvironment = rule2783 _lhsIimportEnvironment
         _patternsOmonos = rule2784 _lhsImonos
         _patternsOnamesInScope = rule2785 _lhsInamesInScope
         _patternsOparentTree = rule2786 _parentTree
         _patternsOpatternMatchWarnings = rule2787 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2759 #-}
   rule2759 = \ ((_lhsIbetaUnique) :: Int) ->
                                    _lhsIbetaUnique + 2
   {-# INLINE rule2760 #-}
   rule2760 = \ _conApply _conConstructor ((_patternsIconstraintslist) :: ConstraintSets) ->
                                    _conApply .>.
                                    Node [ listTree _conConstructor
                                         , Node _patternsIconstraintslist
                                         ]
   {-# INLINE rule2761 #-}
   rule2761 = \ ((_lhsIbetaUnique) :: Int) ->
                                    TVar (_lhsIbetaUnique)
   {-# INLINE rule2762 #-}
   rule2762 = \ ((_lhsIbetaUnique) :: Int) ->
                                    TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule2763 #-}
   rule2763 = \ _beta _betaCon _cinfoApply _cinfoEmpty ((_patternsIbetas) :: Tps) ((_patternsInumberOfPatterns) :: Int) ->
                                    [ (_betaCon .==. foldr (.->.) _beta _patternsIbetas)
                                      (if _patternsInumberOfPatterns == 0  then _cinfoEmpty else _cinfoApply) ]
   {-# INLINE rule2764 #-}
   rule2764 = \ _betaCon _cinfoConstructor ((_lhsIimportEnvironment) :: ImportEnvironment) ((_nameIself) :: Name) ->
                                    case M.lookup _nameIself (valueConstructors _lhsIimportEnvironment) of
                                       Nothing  -> []
                                       Just ctp -> [ (_betaCon .::. ctp) _cinfoConstructor ]
   {-# INLINE rule2765 #-}
   rule2765 = \ _parentTree ->
     resultConstraint "pattern constructor" _parentTree
        [ FolkloreConstraint, HasTrustFactor 10.0 ]
   {-# INLINE rule2766 #-}
   rule2766 = \ _localInfo ((_nameIself) :: Name) _parentTree ((_patternsIinfoTrees) :: InfoTrees) ->
     specialConstraint "pattern application" _parentTree
        (self _localInfo, Just $ nameToUHA_Pat _nameIself)
        [ ApplicationEdge False (map attribute _patternsIinfoTrees) ]
   {-# INLINE rule2767 #-}
   rule2767 = \ _parentTree ->
     resultConstraint "pattern constructor" _parentTree
        [ HasTrustFactor 10.0 ]
   {-# INLINE rule2768 #-}
   rule2768 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2769 #-}
   rule2769 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo _patternsIinfoTrees
   {-# INLINE rule2770 #-}
   rule2770 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2771 #-}
   rule2771 = \ ((_nameIself) :: Name) ((_patternsIelementss) :: [ [PatternElement]       ]) ->
                                         FiniteElement (getNameName _nameIself) : concat _patternsIelementss
   {-# INLINE rule2772 #-}
   rule2772 = \ ((_patternsIpatVarNames) :: Names) ->
     _patternsIpatVarNames
   {-# INLINE rule2773 #-}
   rule2773 = \ ((_patternsIunboundNames) :: Names) ->
     _patternsIunboundNames
   {-# INLINE rule2774 #-}
   rule2774 = \ ((_nameIself) :: Name) ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
     Pattern_Constructor _rangeIself _nameIself _patternsIself
   {-# INLINE rule2775 #-}
   rule2775 = \ _self ->
     _self
   {-# INLINE rule2776 #-}
   rule2776 = \ _beta ->
     _beta
   {-# INLINE rule2777 #-}
   rule2777 = \ ((_patternsIbetaUnique) :: Int) ->
     _patternsIbetaUnique
   {-# INLINE rule2778 #-}
   rule2778 = \ _constraints ->
     _constraints
   {-# INLINE rule2779 #-}
   rule2779 = \ ((_patternsIcounter) :: Int) ->
     _patternsIcounter
   {-# INLINE rule2780 #-}
   rule2780 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
     _patternsIenvironment
   {-# INLINE rule2781 #-}
   rule2781 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
     _patternsIpatternMatchWarnings
   {-# INLINE rule2782 #-}
   rule2782 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2783 #-}
   rule2783 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2784 #-}
   rule2784 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2785 #-}
   rule2785 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2786 #-}
   rule2786 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2787 #-}
   rule2787 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Parenthesized #-}
sem_Pattern_Parenthesized :: T_Range  -> T_Pattern  -> T_Pattern 
sem_Pattern_Parenthesized arg_range_ arg_pattern_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2788 _patternIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2789 _patternIunboundNames
         _self = rule2790 _patternIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2791 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2792 _patternIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2793 _patternIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2794 _patternIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2795 _patternIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2796 _patternIelements
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2797 _patternIenvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2798 _patternIinfoTree
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2799 _patternIpatternMatchWarnings
         _patternObetaUnique = rule2800 _lhsIbetaUnique
         _patternOcounter = rule2801 _lhsIcounter
         _patternOimportEnvironment = rule2802 _lhsIimportEnvironment
         _patternOmonos = rule2803 _lhsImonos
         _patternOnamesInScope = rule2804 _lhsInamesInScope
         _patternOparentTree = rule2805 _lhsIparentTree
         _patternOpatternMatchWarnings = rule2806 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2788 #-}
   rule2788 = \ ((_patternIpatVarNames) :: Names) ->
     _patternIpatVarNames
   {-# INLINE rule2789 #-}
   rule2789 = \ ((_patternIunboundNames) :: Names) ->
     _patternIunboundNames
   {-# INLINE rule2790 #-}
   rule2790 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
     Pattern_Parenthesized _rangeIself _patternIself
   {-# INLINE rule2791 #-}
   rule2791 = \ _self ->
     _self
   {-# INLINE rule2792 #-}
   rule2792 = \ ((_patternIbeta) :: Tp) ->
     _patternIbeta
   {-# INLINE rule2793 #-}
   rule2793 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule2794 #-}
   rule2794 = \ ((_patternIconstraints) :: ConstraintSet) ->
     _patternIconstraints
   {-# INLINE rule2795 #-}
   rule2795 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule2796 #-}
   rule2796 = \ ((_patternIelements) ::   [PatternElement]        ) ->
     _patternIelements
   {-# INLINE rule2797 #-}
   rule2797 = \ ((_patternIenvironment) :: PatternAssumptions) ->
     _patternIenvironment
   {-# INLINE rule2798 #-}
   rule2798 = \ ((_patternIinfoTree) :: InfoTree) ->
     _patternIinfoTree
   {-# INLINE rule2799 #-}
   rule2799 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule2800 #-}
   rule2800 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2801 #-}
   rule2801 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2802 #-}
   rule2802 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2803 #-}
   rule2803 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2804 #-}
   rule2804 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2805 #-}
   rule2805 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2806 #-}
   rule2806 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_InfixConstructor #-}
sem_Pattern_InfixConstructor :: T_Range  -> T_Pattern  -> T_Name  -> T_Pattern  -> T_Pattern 
sem_Pattern_InfixConstructor arg_range_ arg_leftPattern_ arg_constructorOperator_ arg_rightPattern_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _leftPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_leftPattern_))
         _constructorOperatorX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_constructorOperator_))
         _rightPatternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_rightPattern_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _leftPatternIbeta _leftPatternIbetaUnique _leftPatternIconstraints _leftPatternIcounter _leftPatternIelements _leftPatternIenvironment _leftPatternIinfoTree _leftPatternIpatVarNames _leftPatternIpatternMatchWarnings _leftPatternIself _leftPatternIunboundNames) = inv_Pattern_s119 _leftPatternX119 (T_Pattern_vIn118 _leftPatternObetaUnique _leftPatternOcounter _leftPatternOimportEnvironment _leftPatternOmonos _leftPatternOnamesInScope _leftPatternOparentTree _leftPatternOpatternMatchWarnings)
         (T_Name_vOut112 _constructorOperatorIself) = inv_Name_s113 _constructorOperatorX113 (T_Name_vIn112 )
         (T_Pattern_vOut118 _rightPatternIbeta _rightPatternIbetaUnique _rightPatternIconstraints _rightPatternIcounter _rightPatternIelements _rightPatternIenvironment _rightPatternIinfoTree _rightPatternIpatVarNames _rightPatternIpatternMatchWarnings _rightPatternIself _rightPatternIunboundNames) = inv_Pattern_s119 _rightPatternX119 (T_Pattern_vIn118 _rightPatternObetaUnique _rightPatternOcounter _rightPatternOimportEnvironment _rightPatternOmonos _rightPatternOnamesInScope _rightPatternOparentTree _rightPatternOpatternMatchWarnings)
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2807 _leftPatternIenvironment _rightPatternIenvironment
         _leftPatternObetaUnique = rule2808 _lhsIbetaUnique
         _constraints = rule2809 _conApply _conConstructor _leftPatternIconstraints _rightPatternIconstraints
         _beta = rule2810 _lhsIbetaUnique
         _betaCon = rule2811 _lhsIbetaUnique
         _conApply = rule2812 _beta _betaCon _cinfoApply _leftPatternIbeta _rightPatternIbeta
         _conConstructor = rule2813 _betaCon _cinfoConstructor _constructorOperatorIself _lhsIimportEnvironment
         _cinfoConstructor = rule2814 _constructorOperatorIself
         _cinfoApply = rule2815 _constructorOperatorIself _leftPatternIinfoTree _localInfo _parentTree _rightPatternIinfoTree
         _localInfo = rule2816 _beta _lhsImonos _self
         _parentTree = rule2817 _leftPatternIinfoTree _lhsIparentTree _localInfo _rightPatternIinfoTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2818 _parentTree
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2819 _constructorOperatorIself _leftPatternIelements _rightPatternIelements
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2820 _leftPatternIpatVarNames _rightPatternIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2821 _leftPatternIunboundNames _rightPatternIunboundNames
         _self = rule2822 _constructorOperatorIself _leftPatternIself _rangeIself _rightPatternIself
         _lhsOself :: Pattern
         _lhsOself = rule2823 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2824 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2825 _rightPatternIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2826 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2827 _rightPatternIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2828 _rightPatternIpatternMatchWarnings
         _leftPatternOcounter = rule2829 _lhsIcounter
         _leftPatternOimportEnvironment = rule2830 _lhsIimportEnvironment
         _leftPatternOmonos = rule2831 _lhsImonos
         _leftPatternOnamesInScope = rule2832 _lhsInamesInScope
         _leftPatternOparentTree = rule2833 _parentTree
         _leftPatternOpatternMatchWarnings = rule2834 _lhsIpatternMatchWarnings
         _rightPatternObetaUnique = rule2835 _leftPatternIbetaUnique
         _rightPatternOcounter = rule2836 _leftPatternIcounter
         _rightPatternOimportEnvironment = rule2837 _lhsIimportEnvironment
         _rightPatternOmonos = rule2838 _lhsImonos
         _rightPatternOnamesInScope = rule2839 _lhsInamesInScope
         _rightPatternOparentTree = rule2840 _parentTree
         _rightPatternOpatternMatchWarnings = rule2841 _leftPatternIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2807 #-}
   rule2807 = \ ((_leftPatternIenvironment) :: PatternAssumptions) ((_rightPatternIenvironment) :: PatternAssumptions) ->
                                       _leftPatternIenvironment `M.union` _rightPatternIenvironment
   {-# INLINE rule2808 #-}
   rule2808 = \ ((_lhsIbetaUnique) :: Int) ->
                                       _lhsIbetaUnique + 2
   {-# INLINE rule2809 #-}
   rule2809 = \ _conApply _conConstructor ((_leftPatternIconstraints) :: ConstraintSet) ((_rightPatternIconstraints) :: ConstraintSet) ->
                                       _conApply .>.
                                       Node [ listTree _conConstructor
                                            , _leftPatternIconstraints
                                            , _rightPatternIconstraints
                                            ]
   {-# INLINE rule2810 #-}
   rule2810 = \ ((_lhsIbetaUnique) :: Int) ->
                                       TVar _lhsIbetaUnique
   {-# INLINE rule2811 #-}
   rule2811 = \ ((_lhsIbetaUnique) :: Int) ->
                                       TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule2812 #-}
   rule2812 = \ _beta _betaCon _cinfoApply ((_leftPatternIbeta) :: Tp) ((_rightPatternIbeta) :: Tp) ->
                                       [ (_betaCon .==. _leftPatternIbeta .->. _rightPatternIbeta .->. _beta) _cinfoApply ]
   {-# INLINE rule2813 #-}
   rule2813 = \ _betaCon _cinfoConstructor ((_constructorOperatorIself) :: Name) ((_lhsIimportEnvironment) :: ImportEnvironment) ->
                                       case M.lookup _constructorOperatorIself (valueConstructors _lhsIimportEnvironment) of
                                          Nothing  -> []
                                          Just ctp -> [ (_betaCon .::. ctp) _cinfoConstructor ]
   {-# INLINE rule2814 #-}
   rule2814 = \ ((_constructorOperatorIself) :: Name) ->
     variableConstraint "pattern constructor" (nameToUHA_Pat _constructorOperatorIself)
        [ FolkloreConstraint, HasTrustFactor 10.0 ]
   {-# INLINE rule2815 #-}
   rule2815 = \ ((_constructorOperatorIself) :: Name) ((_leftPatternIinfoTree) :: InfoTree) _localInfo _parentTree ((_rightPatternIinfoTree) :: InfoTree) ->
     specialConstraint "infix pattern application" _parentTree
        (self _localInfo, Just $ nameToUHA_Pat  _constructorOperatorIself)
        [ ApplicationEdge True (map attribute [_leftPatternIinfoTree, _rightPatternIinfoTree]) ]
   {-# INLINE rule2816 #-}
   rule2816 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2817 #-}
   rule2817 = \ ((_leftPatternIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_rightPatternIinfoTree) :: InfoTree) ->
                            node _lhsIparentTree _localInfo [_leftPatternIinfoTree, _rightPatternIinfoTree]
   {-# INLINE rule2818 #-}
   rule2818 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2819 #-}
   rule2819 = \ ((_constructorOperatorIself) :: Name) ((_leftPatternIelements) ::   [PatternElement]        ) ((_rightPatternIelements) ::   [PatternElement]        ) ->
                                         FiniteElement (getNameName _constructorOperatorIself) : _leftPatternIelements ++ _rightPatternIelements
   {-# INLINE rule2820 #-}
   rule2820 = \ ((_leftPatternIpatVarNames) :: Names) ((_rightPatternIpatVarNames) :: Names) ->
     _leftPatternIpatVarNames ++ _rightPatternIpatVarNames
   {-# INLINE rule2821 #-}
   rule2821 = \ ((_leftPatternIunboundNames) :: Names) ((_rightPatternIunboundNames) :: Names) ->
     _leftPatternIunboundNames ++ _rightPatternIunboundNames
   {-# INLINE rule2822 #-}
   rule2822 = \ ((_constructorOperatorIself) :: Name) ((_leftPatternIself) :: Pattern) ((_rangeIself) :: Range) ((_rightPatternIself) :: Pattern) ->
     Pattern_InfixConstructor _rangeIself _leftPatternIself _constructorOperatorIself _rightPatternIself
   {-# INLINE rule2823 #-}
   rule2823 = \ _self ->
     _self
   {-# INLINE rule2824 #-}
   rule2824 = \ _beta ->
     _beta
   {-# INLINE rule2825 #-}
   rule2825 = \ ((_rightPatternIbetaUnique) :: Int) ->
     _rightPatternIbetaUnique
   {-# INLINE rule2826 #-}
   rule2826 = \ _constraints ->
     _constraints
   {-# INLINE rule2827 #-}
   rule2827 = \ ((_rightPatternIcounter) :: Int) ->
     _rightPatternIcounter
   {-# INLINE rule2828 #-}
   rule2828 = \ ((_rightPatternIpatternMatchWarnings) :: [Warning]) ->
     _rightPatternIpatternMatchWarnings
   {-# INLINE rule2829 #-}
   rule2829 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2830 #-}
   rule2830 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2831 #-}
   rule2831 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2832 #-}
   rule2832 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2833 #-}
   rule2833 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2834 #-}
   rule2834 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule2835 #-}
   rule2835 = \ ((_leftPatternIbetaUnique) :: Int) ->
     _leftPatternIbetaUnique
   {-# INLINE rule2836 #-}
   rule2836 = \ ((_leftPatternIcounter) :: Int) ->
     _leftPatternIcounter
   {-# INLINE rule2837 #-}
   rule2837 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2838 #-}
   rule2838 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2839 #-}
   rule2839 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2840 #-}
   rule2840 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2841 #-}
   rule2841 = \ ((_leftPatternIpatternMatchWarnings) :: [Warning]) ->
     _leftPatternIpatternMatchWarnings
{-# NOINLINE sem_Pattern_List #-}
sem_Pattern_List :: T_Range  -> T_Patterns  -> T_Pattern 
sem_Pattern_List arg_range_ arg_patterns_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
         _patternsObetaUnique = rule2842 _lhsIbetaUnique
         _constraints = rule2843 _newcon _patternsIbetas _patternsIconstraintslist _zipf
         _beta = rule2844 _lhsIbetaUnique
         _beta' = rule2845 _lhsIbetaUnique
         _newcon = rule2846 _beta _beta' _cinfoResult
         _zipf = rule2847 _beta' _cinfoElem
         _cinfoElem = rule2848 _beta' _localInfo _parentTree _patternsIconstraintslist
         _cinfoResult = rule2849 _parentTree
         _localInfo = rule2850 _beta _lhsImonos _self
         _parentTree = rule2851 _lhsIparentTree _localInfo _patternsIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2852 _parentTree
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2853 _patternsIelementss
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2854 _patternsIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2855 _patternsIunboundNames
         _self = rule2856 _patternsIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2857 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2858 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2859 _patternsIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2860 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2861 _patternsIcounter
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2862 _patternsIenvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2863 _patternsIpatternMatchWarnings
         _patternsOcounter = rule2864 _lhsIcounter
         _patternsOimportEnvironment = rule2865 _lhsIimportEnvironment
         _patternsOmonos = rule2866 _lhsImonos
         _patternsOnamesInScope = rule2867 _lhsInamesInScope
         _patternsOparentTree = rule2868 _parentTree
         _patternsOpatternMatchWarnings = rule2869 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2842 #-}
   rule2842 = \ ((_lhsIbetaUnique) :: Int) ->
                                  _lhsIbetaUnique + 2
   {-# INLINE rule2843 #-}
   rule2843 = \ _newcon ((_patternsIbetas) :: Tps) ((_patternsIconstraintslist) :: ConstraintSets) _zipf ->
                                  _newcon .>.
                                  Node (zipWith3 _zipf _patternsIbetas [0..] _patternsIconstraintslist)
   {-# INLINE rule2844 #-}
   rule2844 = \ ((_lhsIbetaUnique) :: Int) ->
                                  TVar _lhsIbetaUnique
   {-# INLINE rule2845 #-}
   rule2845 = \ ((_lhsIbetaUnique) :: Int) ->
                                  TVar (_lhsIbetaUnique + 1)
   {-# INLINE rule2846 #-}
   rule2846 = \ _beta _beta' _cinfoResult ->
                                  [ (listType _beta' .==. _beta) _cinfoResult ]
   {-# INLINE rule2847 #-}
   rule2847 = \ _beta' _cinfoElem ->
                                  \tp elemNr ctree -> [ (tp .==. _beta') (_cinfoElem elemNr) ] .<. ctree
   {-# INLINE rule2848 #-}
   rule2848 = \ _beta' _localInfo _parentTree ((_patternsIconstraintslist) :: ConstraintSets) ->
     \elemNr ->
     childConstraint elemNr "element of pattern list" _parentTree $
        [ HasTrustFactor 10.0 | length _patternsIconstraintslist < 2 ] ++
        [ Unifier (head (ftv _beta')) ("pattern list", _localInfo, ordinal False (elemNr+1) ++ " element") ]
   {-# INLINE rule2849 #-}
   rule2849 = \ _parentTree ->
     resultConstraint "pattern list" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule2850 #-}
   rule2850 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2851 #-}
   rule2851 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo _patternsIinfoTrees
   {-# INLINE rule2852 #-}
   rule2852 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2853 #-}
   rule2853 = \ ((_patternsIelementss) :: [ [PatternElement]       ]) ->
                                         listPat _patternsIelementss
   {-# INLINE rule2854 #-}
   rule2854 = \ ((_patternsIpatVarNames) :: Names) ->
     _patternsIpatVarNames
   {-# INLINE rule2855 #-}
   rule2855 = \ ((_patternsIunboundNames) :: Names) ->
     _patternsIunboundNames
   {-# INLINE rule2856 #-}
   rule2856 = \ ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
     Pattern_List _rangeIself _patternsIself
   {-# INLINE rule2857 #-}
   rule2857 = \ _self ->
     _self
   {-# INLINE rule2858 #-}
   rule2858 = \ _beta ->
     _beta
   {-# INLINE rule2859 #-}
   rule2859 = \ ((_patternsIbetaUnique) :: Int) ->
     _patternsIbetaUnique
   {-# INLINE rule2860 #-}
   rule2860 = \ _constraints ->
     _constraints
   {-# INLINE rule2861 #-}
   rule2861 = \ ((_patternsIcounter) :: Int) ->
     _patternsIcounter
   {-# INLINE rule2862 #-}
   rule2862 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
     _patternsIenvironment
   {-# INLINE rule2863 #-}
   rule2863 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
     _patternsIpatternMatchWarnings
   {-# INLINE rule2864 #-}
   rule2864 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2865 #-}
   rule2865 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2866 #-}
   rule2866 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2867 #-}
   rule2867 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2868 #-}
   rule2868 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2869 #-}
   rule2869 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Tuple #-}
sem_Pattern_Tuple :: T_Range  -> T_Patterns  -> T_Pattern 
sem_Pattern_Tuple arg_range_ arg_patterns_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternsX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_patterns_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Patterns_vOut121 _patternsIbetaUnique _patternsIbetas _patternsIconstraintslist _patternsIcounter _patternsIelementss _patternsIenvironment _patternsIinfoTrees _patternsInumberOfPatterns _patternsIpatVarNames _patternsIpatternMatchWarnings _patternsIself _patternsIunboundNames) = inv_Patterns_s122 _patternsX122 (T_Patterns_vIn121 _patternsObetaUnique _patternsOcounter _patternsOimportEnvironment _patternsOmonos _patternsOnamesInScope _patternsOparentTree _patternsOpatternMatchWarnings)
         _patternsObetaUnique = rule2870 _lhsIbetaUnique
         _constraints = rule2871 _newcon _patternsIconstraintslist
         _beta = rule2872 _lhsIbetaUnique
         _newcon = rule2873 _beta _cinfo _patternsIbetas
         _cinfo = rule2874 _parentTree
         _localInfo = rule2875 _beta _lhsImonos _self
         _parentTree = rule2876 _lhsIparentTree _localInfo _patternsIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2877 _parentTree
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2878 _patternsIelementss _patternsIself
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2879 _patternsIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2880 _patternsIunboundNames
         _self = rule2881 _patternsIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2882 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2883 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2884 _patternsIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2885 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2886 _patternsIcounter
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2887 _patternsIenvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2888 _patternsIpatternMatchWarnings
         _patternsOcounter = rule2889 _lhsIcounter
         _patternsOimportEnvironment = rule2890 _lhsIimportEnvironment
         _patternsOmonos = rule2891 _lhsImonos
         _patternsOnamesInScope = rule2892 _lhsInamesInScope
         _patternsOparentTree = rule2893 _parentTree
         _patternsOpatternMatchWarnings = rule2894 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2870 #-}
   rule2870 = \ ((_lhsIbetaUnique) :: Int) ->
                                 _lhsIbetaUnique + 1
   {-# INLINE rule2871 #-}
   rule2871 = \ _newcon ((_patternsIconstraintslist) :: ConstraintSets) ->
                                 _newcon .>. Node _patternsIconstraintslist
   {-# INLINE rule2872 #-}
   rule2872 = \ ((_lhsIbetaUnique) :: Int) ->
                                 TVar _lhsIbetaUnique
   {-# INLINE rule2873 #-}
   rule2873 = \ _beta _cinfo ((_patternsIbetas) :: Tps) ->
                                 [ (tupleType _patternsIbetas .==. _beta) _cinfo ]
   {-# INLINE rule2874 #-}
   rule2874 = \ _parentTree ->
     resultConstraint "pattern tuple" _parentTree
     [ FolkloreConstraint ]
   {-# INLINE rule2875 #-}
   rule2875 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2876 #-}
   rule2876 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternsIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo _patternsIinfoTrees
   {-# INLINE rule2877 #-}
   rule2877 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2878 #-}
   rule2878 = \ ((_patternsIelementss) :: [ [PatternElement]       ]) ((_patternsIself) :: Patterns) ->
                                         FiniteElement ("(" ++ replicate (length $ tail _patternsIself) ',' ++ ")") : concat _patternsIelementss
   {-# INLINE rule2879 #-}
   rule2879 = \ ((_patternsIpatVarNames) :: Names) ->
     _patternsIpatVarNames
   {-# INLINE rule2880 #-}
   rule2880 = \ ((_patternsIunboundNames) :: Names) ->
     _patternsIunboundNames
   {-# INLINE rule2881 #-}
   rule2881 = \ ((_patternsIself) :: Patterns) ((_rangeIself) :: Range) ->
     Pattern_Tuple _rangeIself _patternsIself
   {-# INLINE rule2882 #-}
   rule2882 = \ _self ->
     _self
   {-# INLINE rule2883 #-}
   rule2883 = \ _beta ->
     _beta
   {-# INLINE rule2884 #-}
   rule2884 = \ ((_patternsIbetaUnique) :: Int) ->
     _patternsIbetaUnique
   {-# INLINE rule2885 #-}
   rule2885 = \ _constraints ->
     _constraints
   {-# INLINE rule2886 #-}
   rule2886 = \ ((_patternsIcounter) :: Int) ->
     _patternsIcounter
   {-# INLINE rule2887 #-}
   rule2887 = \ ((_patternsIenvironment) :: PatternAssumptions) ->
     _patternsIenvironment
   {-# INLINE rule2888 #-}
   rule2888 = \ ((_patternsIpatternMatchWarnings) :: [Warning]) ->
     _patternsIpatternMatchWarnings
   {-# INLINE rule2889 #-}
   rule2889 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2890 #-}
   rule2890 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2891 #-}
   rule2891 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2892 #-}
   rule2892 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2893 #-}
   rule2893 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2894 #-}
   rule2894 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Record #-}
sem_Pattern_Record :: T_Range  -> T_Name  -> T_RecordPatternBindings  -> T_Pattern 
sem_Pattern_Record arg_range_ arg_name_ arg_recordPatternBindings_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _recordPatternBindingsX146 = Control.Monad.Identity.runIdentity (attach_T_RecordPatternBindings (arg_recordPatternBindings_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_RecordPatternBindings_vOut145 _recordPatternBindingsIcounter _recordPatternBindingsIpatternMatchWarnings _recordPatternBindingsIself _recordPatternBindingsIunboundNames) = inv_RecordPatternBindings_s146 _recordPatternBindingsX146 (T_RecordPatternBindings_vIn145 _recordPatternBindingsOcounter _recordPatternBindingsOnamesInScope _recordPatternBindingsOpatternMatchWarnings)
         _infoTree = rule2895  ()
         (_beta,_constraints,_environment) = rule2896  ()
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2897  ()
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2898  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2899 _recordPatternBindingsIunboundNames
         _self = rule2900 _nameIself _rangeIself _recordPatternBindingsIself
         _lhsOself :: Pattern
         _lhsOself = rule2901 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2902 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2903 _lhsIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2904 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2905 _recordPatternBindingsIcounter
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2906 _environment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2907 _infoTree
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2908 _recordPatternBindingsIpatternMatchWarnings
         _recordPatternBindingsOcounter = rule2909 _lhsIcounter
         _recordPatternBindingsOnamesInScope = rule2910 _lhsInamesInScope
         _recordPatternBindingsOpatternMatchWarnings = rule2911 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2895 #-}
   rule2895 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule2896 #-}
   rule2896 = \  (_ :: ()) ->
                                                       internalError "PartialSyntax.ag" "n/a" "Pattern.Record"
   {-# INLINE rule2897 #-}
   rule2897 = \  (_ :: ()) ->
                                         pmError "Pattern_Record.elements" "Records are not supported"
   {-# INLINE rule2898 #-}
   rule2898 = \  (_ :: ()) ->
     []
   {-# INLINE rule2899 #-}
   rule2899 = \ ((_recordPatternBindingsIunboundNames) :: Names) ->
     _recordPatternBindingsIunboundNames
   {-# INLINE rule2900 #-}
   rule2900 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_recordPatternBindingsIself) :: RecordPatternBindings) ->
     Pattern_Record _rangeIself _nameIself _recordPatternBindingsIself
   {-# INLINE rule2901 #-}
   rule2901 = \ _self ->
     _self
   {-# INLINE rule2902 #-}
   rule2902 = \ _beta ->
     _beta
   {-# INLINE rule2903 #-}
   rule2903 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2904 #-}
   rule2904 = \ _constraints ->
     _constraints
   {-# INLINE rule2905 #-}
   rule2905 = \ ((_recordPatternBindingsIcounter) :: Int) ->
     _recordPatternBindingsIcounter
   {-# INLINE rule2906 #-}
   rule2906 = \ _environment ->
     _environment
   {-# INLINE rule2907 #-}
   rule2907 = \ _infoTree ->
     _infoTree
   {-# INLINE rule2908 #-}
   rule2908 = \ ((_recordPatternBindingsIpatternMatchWarnings) :: [Warning]) ->
     _recordPatternBindingsIpatternMatchWarnings
   {-# INLINE rule2909 #-}
   rule2909 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2910 #-}
   rule2910 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2911 #-}
   rule2911 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Negate #-}
sem_Pattern_Negate :: T_Range  -> T_Literal  -> T_Pattern 
sem_Pattern_Negate arg_range_ arg_literal_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2912 _lhsIbetaUnique
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2913  ()
         _constraints = rule2914 _newcon
         _beta = rule2915 _lhsIbetaUnique
         _newcon = rule2916 _beta _cinfo _lhsIimportEnvironment _literalIliteralType
         _cinfo = rule2917 _parentTree
         _localInfo = rule2918 _beta _lhsImonos _self
         _parentTree = rule2919 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2920 _parentTree
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2921  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2922  ()
         _self = rule2923 _literalIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2924 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2925 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2926 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2927 _lhsIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2928 _literalIelements
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2929 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2912 #-}
   rule2912 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule2913 #-}
   rule2913 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule2914 #-}
   rule2914 = \ _newcon ->
                            listTree _newcon
   {-# INLINE rule2915 #-}
   rule2915 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule2916 #-}
   rule2916 = \ _beta _cinfo ((_lhsIimportEnvironment) :: ImportEnvironment) ((_literalIliteralType) :: Tp) ->
                            let standard = makeScheme [] [Predicate "Num" (TVar 0)] (TVar 0 .->. TVar 0)
                                tpscheme = M.findWithDefault standard (nameFromString "negate") (typeEnvironment _lhsIimportEnvironment)
                            in [ (_literalIliteralType .->. _beta .::. tpscheme) _cinfo]
   {-# INLINE rule2917 #-}
   rule2917 = \ _parentTree ->
     resultConstraint "pattern negation" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule2918 #-}
   rule2918 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2919 #-}
   rule2919 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule2920 #-}
   rule2920 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2921 #-}
   rule2921 = \  (_ :: ()) ->
     []
   {-# INLINE rule2922 #-}
   rule2922 = \  (_ :: ()) ->
     []
   {-# INLINE rule2923 #-}
   rule2923 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
     Pattern_Negate _rangeIself _literalIself
   {-# INLINE rule2924 #-}
   rule2924 = \ _self ->
     _self
   {-# INLINE rule2925 #-}
   rule2925 = \ _beta ->
     _beta
   {-# INLINE rule2926 #-}
   rule2926 = \ _constraints ->
     _constraints
   {-# INLINE rule2927 #-}
   rule2927 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2928 #-}
   rule2928 = \ ((_literalIelements) ::   [PatternElement]        ) ->
     _literalIelements
   {-# INLINE rule2929 #-}
   rule2929 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_As #-}
sem_Pattern_As :: T_Range  -> T_Name  -> T_Pattern  -> T_Pattern 
sem_Pattern_As arg_range_ arg_name_ arg_pattern_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2930 _beta _nameIself _patternIenvironment
         _patternObetaUnique = rule2931 _lhsIbetaUnique
         _constraints = rule2932 _lhsIbetaUnique _newcon _patternIconstraints
         _beta = rule2933 _lhsIbetaUnique
         _newcon = rule2934 _beta _cinfo _patternIbeta
         _cinfo = rule2935 _localInfo _nameIself _parentTree
         _localInfo = rule2936 _beta _lhsImonos _self
         _parentTree = rule2937 _lhsIparentTree _localInfo _patternIinfoTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2938 _parentTree
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2939 _nameIself _patternIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2940 _patternIunboundNames
         _self = rule2941 _nameIself _patternIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2942 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2943 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2944 _patternIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2945 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2946 _patternIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2947 _patternIelements
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2948 _patternIpatternMatchWarnings
         _patternOcounter = rule2949 _lhsIcounter
         _patternOimportEnvironment = rule2950 _lhsIimportEnvironment
         _patternOmonos = rule2951 _lhsImonos
         _patternOnamesInScope = rule2952 _lhsInamesInScope
         _patternOparentTree = rule2953 _parentTree
         _patternOpatternMatchWarnings = rule2954 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2930 #-}
   rule2930 = \ _beta ((_nameIself) :: Name) ((_patternIenvironment) :: PatternAssumptions) ->
                                M.insert _nameIself _beta _patternIenvironment
   {-# INLINE rule2931 #-}
   rule2931 = \ ((_lhsIbetaUnique) :: Int) ->
                                _lhsIbetaUnique + 1
   {-# INLINE rule2932 #-}
   rule2932 = \ ((_lhsIbetaUnique) :: Int) _newcon ((_patternIconstraints) :: ConstraintSet) ->
                                _newcon .>.
                                Node [ Receive _lhsIbetaUnique
                                     , _patternIconstraints
                                     ]
   {-# INLINE rule2933 #-}
   rule2933 = \ ((_lhsIbetaUnique) :: Int) ->
                                TVar _lhsIbetaUnique
   {-# INLINE rule2934 #-}
   rule2934 = \ _beta _cinfo ((_patternIbeta) :: Tp) ->
                                [ (_beta .==. _patternIbeta) _cinfo ]
   {-# INLINE rule2935 #-}
   rule2935 = \ _localInfo ((_nameIself) :: Name) _parentTree ->
     specialConstraint "as pattern" _parentTree
        (self _localInfo, Just $ nameToUHA_Pat _nameIself)
        []
   {-# INLINE rule2936 #-}
   rule2936 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2937 #-}
   rule2937 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ->
                            node _lhsIparentTree _localInfo [_patternIinfoTree]
   {-# INLINE rule2938 #-}
   rule2938 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2939 #-}
   rule2939 = \ ((_nameIself) :: Name) ((_patternIpatVarNames) :: Names) ->
                                     _nameIself : _patternIpatVarNames
   {-# INLINE rule2940 #-}
   rule2940 = \ ((_patternIunboundNames) :: Names) ->
     _patternIunboundNames
   {-# INLINE rule2941 #-}
   rule2941 = \ ((_nameIself) :: Name) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
     Pattern_As _rangeIself _nameIself _patternIself
   {-# INLINE rule2942 #-}
   rule2942 = \ _self ->
     _self
   {-# INLINE rule2943 #-}
   rule2943 = \ _beta ->
     _beta
   {-# INLINE rule2944 #-}
   rule2944 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule2945 #-}
   rule2945 = \ _constraints ->
     _constraints
   {-# INLINE rule2946 #-}
   rule2946 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule2947 #-}
   rule2947 = \ ((_patternIelements) ::   [PatternElement]        ) ->
     _patternIelements
   {-# INLINE rule2948 #-}
   rule2948 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule2949 #-}
   rule2949 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2950 #-}
   rule2950 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2951 #-}
   rule2951 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2952 #-}
   rule2952 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2953 #-}
   rule2953 = \ _parentTree ->
     _parentTree
   {-# INLINE rule2954 #-}
   rule2954 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Wildcard #-}
sem_Pattern_Wildcard :: T_Range  -> T_Pattern 
sem_Pattern_Wildcard arg_range_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2955 _lhsIbetaUnique
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2956  ()
         _constraints = rule2957  ()
         _beta = rule2958 _lhsIbetaUnique
         _localInfo = rule2959 _beta _lhsImonos _self
         _parentTree = rule2960 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2961 _parentTree
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2962  ()
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2963  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2964  ()
         _self = rule2965 _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2966 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2967 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2968 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2969 _lhsIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2970 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2955 #-}
   rule2955 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule2956 #-}
   rule2956 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule2957 #-}
   rule2957 = \  (_ :: ()) ->
                            emptyTree
   {-# INLINE rule2958 #-}
   rule2958 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule2959 #-}
   rule2959 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule2960 #-}
   rule2960 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule2961 #-}
   rule2961 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule2962 #-}
   rule2962 = \  (_ :: ()) ->
                                         [WildcardElement]
   {-# INLINE rule2963 #-}
   rule2963 = \  (_ :: ()) ->
     []
   {-# INLINE rule2964 #-}
   rule2964 = \  (_ :: ()) ->
     []
   {-# INLINE rule2965 #-}
   rule2965 = \ ((_rangeIself) :: Range) ->
     Pattern_Wildcard _rangeIself
   {-# INLINE rule2966 #-}
   rule2966 = \ _self ->
     _self
   {-# INLINE rule2967 #-}
   rule2967 = \ _beta ->
     _beta
   {-# INLINE rule2968 #-}
   rule2968 = \ _constraints ->
     _constraints
   {-# INLINE rule2969 #-}
   rule2969 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2970 #-}
   rule2970 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Irrefutable #-}
sem_Pattern_Irrefutable :: T_Range  -> T_Pattern  -> T_Pattern 
sem_Pattern_Irrefutable arg_range_ arg_pattern_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2971 _patternIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2972 _patternIunboundNames
         _self = rule2973 _patternIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2974 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2975 _patternIbeta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2976 _patternIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2977 _patternIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule2978 _patternIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2979 _patternIelements
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule2980 _patternIenvironment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule2981 _patternIinfoTree
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule2982 _patternIpatternMatchWarnings
         _patternObetaUnique = rule2983 _lhsIbetaUnique
         _patternOcounter = rule2984 _lhsIcounter
         _patternOimportEnvironment = rule2985 _lhsIimportEnvironment
         _patternOmonos = rule2986 _lhsImonos
         _patternOnamesInScope = rule2987 _lhsInamesInScope
         _patternOparentTree = rule2988 _lhsIparentTree
         _patternOpatternMatchWarnings = rule2989 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2971 #-}
   rule2971 = \ ((_patternIpatVarNames) :: Names) ->
     _patternIpatVarNames
   {-# INLINE rule2972 #-}
   rule2972 = \ ((_patternIunboundNames) :: Names) ->
     _patternIunboundNames
   {-# INLINE rule2973 #-}
   rule2973 = \ ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
     Pattern_Irrefutable _rangeIself _patternIself
   {-# INLINE rule2974 #-}
   rule2974 = \ _self ->
     _self
   {-# INLINE rule2975 #-}
   rule2975 = \ ((_patternIbeta) :: Tp) ->
     _patternIbeta
   {-# INLINE rule2976 #-}
   rule2976 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule2977 #-}
   rule2977 = \ ((_patternIconstraints) :: ConstraintSet) ->
     _patternIconstraints
   {-# INLINE rule2978 #-}
   rule2978 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule2979 #-}
   rule2979 = \ ((_patternIelements) ::   [PatternElement]        ) ->
     _patternIelements
   {-# INLINE rule2980 #-}
   rule2980 = \ ((_patternIenvironment) :: PatternAssumptions) ->
     _patternIenvironment
   {-# INLINE rule2981 #-}
   rule2981 = \ ((_patternIinfoTree) :: InfoTree) ->
     _patternIinfoTree
   {-# INLINE rule2982 #-}
   rule2982 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule2983 #-}
   rule2983 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2984 #-}
   rule2984 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule2985 #-}
   rule2985 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule2986 #-}
   rule2986 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule2987 #-}
   rule2987 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule2988 #-}
   rule2988 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule2989 #-}
   rule2989 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_Successor #-}
sem_Pattern_Successor :: T_Range  -> T_Name  -> T_Literal  -> T_Pattern 
sem_Pattern_Successor arg_range_ arg_name_ arg_literal_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
         _infoTree = rule2990  ()
         (_beta,_constraints,_environment) = rule2991  ()
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule2992  ()
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule2993  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule2994  ()
         _self = rule2995 _literalIself _nameIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule2996 _self
         _lhsObeta :: Tp
         _lhsObeta = rule2997 _beta
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule2998 _lhsIbetaUnique
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule2999 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule3000 _lhsIcounter
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule3001 _environment
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3002 _infoTree
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3003 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule2990 #-}
   rule2990 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule2991 #-}
   rule2991 = \  (_ :: ()) ->
                                                       internalError "PartialSyntax.ag" "n/a" "Pattern.Successor"
   {-# INLINE rule2992 #-}
   rule2992 = \  (_ :: ()) ->
                                         pmError "Pattern_Successor.elements" "Successors are not supported"
   {-# INLINE rule2993 #-}
   rule2993 = \  (_ :: ()) ->
     []
   {-# INLINE rule2994 #-}
   rule2994 = \  (_ :: ()) ->
     []
   {-# INLINE rule2995 #-}
   rule2995 = \ ((_literalIself) :: Literal) ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Pattern_Successor _rangeIself _nameIself _literalIself
   {-# INLINE rule2996 #-}
   rule2996 = \ _self ->
     _self
   {-# INLINE rule2997 #-}
   rule2997 = \ _beta ->
     _beta
   {-# INLINE rule2998 #-}
   rule2998 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule2999 #-}
   rule2999 = \ _constraints ->
     _constraints
   {-# INLINE rule3000 #-}
   rule3000 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3001 #-}
   rule3001 = \ _environment ->
     _environment
   {-# INLINE rule3002 #-}
   rule3002 = \ _infoTree ->
     _infoTree
   {-# INLINE rule3003 #-}
   rule3003 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
{-# NOINLINE sem_Pattern_NegateFloat #-}
sem_Pattern_NegateFloat :: T_Range  -> T_Literal  -> T_Pattern 
sem_Pattern_NegateFloat arg_range_ arg_literal_ = T_Pattern (return st119) where
   {-# NOINLINE st119 #-}
   st119 = let
      v118 :: T_Pattern_v118 
      v118 = \ (T_Pattern_vIn118 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _literalX86 = Control.Monad.Identity.runIdentity (attach_T_Literal (arg_literal_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Literal_vOut85 _literalIelements _literalIliteralType _literalIself) = inv_Literal_s86 _literalX86 (T_Literal_vIn85 )
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3004 _lhsIbetaUnique
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule3005  ()
         _constraints = rule3006 _newcon
         _beta = rule3007 _lhsIbetaUnique
         _newcon = rule3008 _beta _cinfo
         _cinfo = rule3009 _parentTree
         _localInfo = rule3010 _beta _lhsImonos _self
         _parentTree = rule3011 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3012 _parentTree
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule3013  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3014  ()
         _self = rule3015 _literalIself _rangeIself
         _lhsOself :: Pattern
         _lhsOself = rule3016 _self
         _lhsObeta :: Tp
         _lhsObeta = rule3017 _beta
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3018 _constraints
         _lhsOcounter :: Int
         _lhsOcounter = rule3019 _lhsIcounter
         _lhsOelements ::   [PatternElement]        
         _lhsOelements = rule3020 _literalIelements
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3021 _lhsIpatternMatchWarnings
         __result_ = T_Pattern_vOut118 _lhsObeta _lhsObetaUnique _lhsOconstraints _lhsOcounter _lhsOelements _lhsOenvironment _lhsOinfoTree _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Pattern_s119 v118
   {-# INLINE rule3004 #-}
   rule3004 = \ ((_lhsIbetaUnique) :: Int) ->
                            _lhsIbetaUnique + 1
   {-# INLINE rule3005 #-}
   rule3005 = \  (_ :: ()) ->
                            noAssumptions
   {-# INLINE rule3006 #-}
   rule3006 = \ _newcon ->
                            listTree _newcon
   {-# INLINE rule3007 #-}
   rule3007 = \ ((_lhsIbetaUnique) :: Int) ->
                            TVar _lhsIbetaUnique
   {-# INLINE rule3008 #-}
   rule3008 = \ _beta _cinfo ->
                            [ (floatType .==. _beta) _cinfo ]
   {-# INLINE rule3009 #-}
   rule3009 = \ _parentTree ->
     resultConstraint "pattern negation" _parentTree
        [ FolkloreConstraint ]
   {-# INLINE rule3010 #-}
   rule3010 = \ _beta ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Pat _self
                                      , assignedType = Just _beta
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3011 #-}
   rule3011 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule3012 #-}
   rule3012 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3013 #-}
   rule3013 = \  (_ :: ()) ->
     []
   {-# INLINE rule3014 #-}
   rule3014 = \  (_ :: ()) ->
     []
   {-# INLINE rule3015 #-}
   rule3015 = \ ((_literalIself) :: Literal) ((_rangeIself) :: Range) ->
     Pattern_NegateFloat _rangeIself _literalIself
   {-# INLINE rule3016 #-}
   rule3016 = \ _self ->
     _self
   {-# INLINE rule3017 #-}
   rule3017 = \ _beta ->
     _beta
   {-# INLINE rule3018 #-}
   rule3018 = \ _constraints ->
     _constraints
   {-# INLINE rule3019 #-}
   rule3019 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3020 #-}
   rule3020 = \ ((_literalIelements) ::   [PatternElement]        ) ->
     _literalIelements
   {-# INLINE rule3021 #-}
   rule3021 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings

-- Patterns ----------------------------------------------------
-- wrapper
data Inh_Patterns  = Inh_Patterns { betaUnique_Inh_Patterns :: (Int), counter_Inh_Patterns :: (Int), importEnvironment_Inh_Patterns :: (ImportEnvironment), monos_Inh_Patterns :: (Monos), namesInScope_Inh_Patterns :: (Names), parentTree_Inh_Patterns :: (InfoTree), patternMatchWarnings_Inh_Patterns :: ([Warning]) }
data Syn_Patterns  = Syn_Patterns { betaUnique_Syn_Patterns :: (Int), betas_Syn_Patterns :: (Tps), constraintslist_Syn_Patterns :: (ConstraintSets), counter_Syn_Patterns :: (Int), elementss_Syn_Patterns :: ([ [PatternElement]       ]), environment_Syn_Patterns :: (PatternAssumptions), infoTrees_Syn_Patterns :: (InfoTrees), numberOfPatterns_Syn_Patterns :: (Int), patVarNames_Syn_Patterns :: (Names), patternMatchWarnings_Syn_Patterns :: ([Warning]), self_Syn_Patterns :: (Patterns), unboundNames_Syn_Patterns :: (Names) }
{-# INLINABLE wrap_Patterns #-}
wrap_Patterns :: T_Patterns  -> Inh_Patterns  -> (Syn_Patterns )
wrap_Patterns (T_Patterns act) (Inh_Patterns _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Patterns_vIn121 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings
        (T_Patterns_vOut121 _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_Patterns_s122 sem arg)
        return (Syn_Patterns _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
   )

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

-- semantic domain
newtype T_Patterns  = T_Patterns {
                                 attach_T_Patterns :: Identity (T_Patterns_s122 )
                                 }
newtype T_Patterns_s122  = C_Patterns_s122 {
                                           inv_Patterns_s122 :: (T_Patterns_v121 )
                                           }
data T_Patterns_s123  = C_Patterns_s123
type T_Patterns_v121  = (T_Patterns_vIn121 ) -> (T_Patterns_vOut121 )
data T_Patterns_vIn121  = T_Patterns_vIn121 (Int) (Int) (ImportEnvironment) (Monos) (Names) (InfoTree) ([Warning])
data T_Patterns_vOut121  = T_Patterns_vOut121 (Int) (Tps) (ConstraintSets) (Int) ([ [PatternElement]       ]) (PatternAssumptions) (InfoTrees) (Int) (Names) ([Warning]) (Patterns) (Names)
{-# NOINLINE sem_Patterns_Cons #-}
sem_Patterns_Cons :: T_Pattern  -> T_Patterns  -> T_Patterns 
sem_Patterns_Cons arg_hd_ arg_tl_ = T_Patterns (return st122) where
   {-# NOINLINE st122 #-}
   st122 = let
      v121 :: T_Patterns_v121 
      v121 = \ (T_Patterns_vIn121 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _hdX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_hd_))
         _tlX122 = Control.Monad.Identity.runIdentity (attach_T_Patterns (arg_tl_))
         (T_Pattern_vOut118 _hdIbeta _hdIbetaUnique _hdIconstraints _hdIcounter _hdIelements _hdIenvironment _hdIinfoTree _hdIpatVarNames _hdIpatternMatchWarnings _hdIself _hdIunboundNames) = inv_Pattern_s119 _hdX119 (T_Pattern_vIn118 _hdObetaUnique _hdOcounter _hdOimportEnvironment _hdOmonos _hdOnamesInScope _hdOparentTree _hdOpatternMatchWarnings)
         (T_Patterns_vOut121 _tlIbetaUnique _tlIbetas _tlIconstraintslist _tlIcounter _tlIelementss _tlIenvironment _tlIinfoTrees _tlInumberOfPatterns _tlIpatVarNames _tlIpatternMatchWarnings _tlIself _tlIunboundNames) = inv_Patterns_s122 _tlX122 (T_Patterns_vIn121 _tlObetaUnique _tlOcounter _tlOimportEnvironment _tlOmonos _tlOnamesInScope _tlOparentTree _tlOpatternMatchWarnings)
         _lhsObetas :: Tps
         _lhsObetas = rule3022 _hdIbeta _tlIbetas
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule3023 _hdIenvironment _tlIenvironment
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule3024 _tlInumberOfPatterns
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule3025 _hdIconstraints _tlIconstraintslist
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule3026 _hdIinfoTree _tlIinfoTrees
         _lhsOelementss :: [ [PatternElement]       ]
         _lhsOelementss = rule3027 _hdIelements _tlIelementss
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule3028 _hdIpatVarNames _tlIpatVarNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3029 _hdIunboundNames _tlIunboundNames
         _self = rule3030 _hdIself _tlIself
         _lhsOself :: Patterns
         _lhsOself = rule3031 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3032 _tlIbetaUnique
         _lhsOcounter :: Int
         _lhsOcounter = rule3033 _tlIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3034 _tlIpatternMatchWarnings
         _hdObetaUnique = rule3035 _lhsIbetaUnique
         _hdOcounter = rule3036 _lhsIcounter
         _hdOimportEnvironment = rule3037 _lhsIimportEnvironment
         _hdOmonos = rule3038 _lhsImonos
         _hdOnamesInScope = rule3039 _lhsInamesInScope
         _hdOparentTree = rule3040 _lhsIparentTree
         _hdOpatternMatchWarnings = rule3041 _lhsIpatternMatchWarnings
         _tlObetaUnique = rule3042 _hdIbetaUnique
         _tlOcounter = rule3043 _hdIcounter
         _tlOimportEnvironment = rule3044 _lhsIimportEnvironment
         _tlOmonos = rule3045 _lhsImonos
         _tlOnamesInScope = rule3046 _lhsInamesInScope
         _tlOparentTree = rule3047 _lhsIparentTree
         _tlOpatternMatchWarnings = rule3048 _hdIpatternMatchWarnings
         __result_ = T_Patterns_vOut121 _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Patterns_s122 v121
   {-# INLINE rule3022 #-}
   rule3022 = \ ((_hdIbeta) :: Tp) ((_tlIbetas) :: Tps) ->
                                 _hdIbeta : _tlIbetas
   {-# INLINE rule3023 #-}
   rule3023 = \ ((_hdIenvironment) :: PatternAssumptions) ((_tlIenvironment) :: PatternAssumptions) ->
                                 _hdIenvironment `M.union` _tlIenvironment
   {-# INLINE rule3024 #-}
   rule3024 = \ ((_tlInumberOfPatterns) :: Int) ->
                                 1 + _tlInumberOfPatterns
   {-# INLINE rule3025 #-}
   rule3025 = \ ((_hdIconstraints) :: ConstraintSet) ((_tlIconstraintslist) :: ConstraintSets) ->
                                 _hdIconstraints : _tlIconstraintslist
   {-# INLINE rule3026 #-}
   rule3026 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTree : _tlIinfoTrees
   {-# INLINE rule3027 #-}
   rule3027 = \ ((_hdIelements) ::   [PatternElement]        ) ((_tlIelementss) :: [ [PatternElement]       ]) ->
                                         _hdIelements : _tlIelementss
   {-# INLINE rule3028 #-}
   rule3028 = \ ((_hdIpatVarNames) :: Names) ((_tlIpatVarNames) :: Names) ->
     _hdIpatVarNames ++ _tlIpatVarNames
   {-# INLINE rule3029 #-}
   rule3029 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule3030 #-}
   rule3030 = \ ((_hdIself) :: Pattern) ((_tlIself) :: Patterns) ->
     (:) _hdIself _tlIself
   {-# INLINE rule3031 #-}
   rule3031 = \ _self ->
     _self
   {-# INLINE rule3032 #-}
   rule3032 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule3033 #-}
   rule3033 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule3034 #-}
   rule3034 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule3035 #-}
   rule3035 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3036 #-}
   rule3036 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3037 #-}
   rule3037 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3038 #-}
   rule3038 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3039 #-}
   rule3039 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3040 #-}
   rule3040 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule3041 #-}
   rule3041 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3042 #-}
   rule3042 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule3043 #-}
   rule3043 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule3044 #-}
   rule3044 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3045 #-}
   rule3045 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3046 #-}
   rule3046 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3047 #-}
   rule3047 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule3048 #-}
   rule3048 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
{-# NOINLINE sem_Patterns_Nil #-}
sem_Patterns_Nil ::  T_Patterns 
sem_Patterns_Nil  = T_Patterns (return st122) where
   {-# NOINLINE st122 #-}
   st122 = let
      v121 :: T_Patterns_v121 
      v121 = \ (T_Patterns_vIn121 _lhsIbetaUnique _lhsIcounter _lhsIimportEnvironment _lhsImonos _lhsInamesInScope _lhsIparentTree _lhsIpatternMatchWarnings) -> ( let
         _lhsObetas :: Tps
         _lhsObetas = rule3049  ()
         _lhsOenvironment :: PatternAssumptions
         _lhsOenvironment = rule3050  ()
         _lhsOnumberOfPatterns :: Int
         _lhsOnumberOfPatterns = rule3051  ()
         _lhsOconstraintslist :: ConstraintSets
         _lhsOconstraintslist = rule3052  ()
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule3053  ()
         _lhsOelementss :: [ [PatternElement]       ]
         _lhsOelementss = rule3054  ()
         _lhsOpatVarNames :: Names
         _lhsOpatVarNames = rule3055  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3056  ()
         _self = rule3057  ()
         _lhsOself :: Patterns
         _lhsOself = rule3058 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3059 _lhsIbetaUnique
         _lhsOcounter :: Int
         _lhsOcounter = rule3060 _lhsIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3061 _lhsIpatternMatchWarnings
         __result_ = T_Patterns_vOut121 _lhsObetaUnique _lhsObetas _lhsOconstraintslist _lhsOcounter _lhsOelementss _lhsOenvironment _lhsOinfoTrees _lhsOnumberOfPatterns _lhsOpatVarNames _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_Patterns_s122 v121
   {-# INLINE rule3049 #-}
   rule3049 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule3050 #-}
   rule3050 = \  (_ :: ()) ->
                                 noAssumptions
   {-# INLINE rule3051 #-}
   rule3051 = \  (_ :: ()) ->
                                 0
   {-# INLINE rule3052 #-}
   rule3052 = \  (_ :: ()) ->
                                 []
   {-# INLINE rule3053 #-}
   rule3053 = \  (_ :: ()) ->
                               []
   {-# INLINE rule3054 #-}
   rule3054 = \  (_ :: ()) ->
                                         []
   {-# INLINE rule3055 #-}
   rule3055 = \  (_ :: ()) ->
     []
   {-# INLINE rule3056 #-}
   rule3056 = \  (_ :: ()) ->
     []
   {-# INLINE rule3057 #-}
   rule3057 = \  (_ :: ()) ->
     []
   {-# INLINE rule3058 #-}
   rule3058 = \ _self ->
     _self
   {-# INLINE rule3059 #-}
   rule3059 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3060 #-}
   rule3060 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3061 #-}
   rule3061 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings

-- Position ----------------------------------------------------
-- wrapper
data Inh_Position  = Inh_Position {  }
data Syn_Position  = Syn_Position { self_Syn_Position :: (Position) }
{-# INLINABLE wrap_Position #-}
wrap_Position :: T_Position  -> Inh_Position  -> (Syn_Position )
wrap_Position (T_Position act) (Inh_Position ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Position_vIn124 
        (T_Position_vOut124 _lhsOself) <- return (inv_Position_s125 sem arg)
        return (Syn_Position _lhsOself)
   )

-- cata
{-# NOINLINE sem_Position #-}
sem_Position :: Position  -> T_Position 
sem_Position ( Position_Position filename_ line_ column_ ) = sem_Position_Position filename_ line_ column_
sem_Position ( Position_Unknown  ) = sem_Position_Unknown 

-- semantic domain
newtype T_Position  = T_Position {
                                 attach_T_Position :: Identity (T_Position_s125 )
                                 }
newtype T_Position_s125  = C_Position_s125 {
                                           inv_Position_s125 :: (T_Position_v124 )
                                           }
data T_Position_s126  = C_Position_s126
type T_Position_v124  = (T_Position_vIn124 ) -> (T_Position_vOut124 )
data T_Position_vIn124  = T_Position_vIn124 
data T_Position_vOut124  = T_Position_vOut124 (Position)
{-# NOINLINE sem_Position_Position #-}
sem_Position_Position :: (String) -> (Int) -> (Int) -> T_Position 
sem_Position_Position arg_filename_ arg_line_ arg_column_ = T_Position (return st125) where
   {-# NOINLINE st125 #-}
   st125 = let
      v124 :: T_Position_v124 
      v124 = \ (T_Position_vIn124 ) -> ( let
         _self = rule3062 arg_column_ arg_filename_ arg_line_
         _lhsOself :: Position
         _lhsOself = rule3063 _self
         __result_ = T_Position_vOut124 _lhsOself
         in __result_ )
     in C_Position_s125 v124
   {-# INLINE rule3062 #-}
   rule3062 = \ column_ filename_ line_ ->
     Position_Position filename_ line_ column_
   {-# INLINE rule3063 #-}
   rule3063 = \ _self ->
     _self
{-# NOINLINE sem_Position_Unknown #-}
sem_Position_Unknown ::  T_Position 
sem_Position_Unknown  = T_Position (return st125) where
   {-# NOINLINE st125 #-}
   st125 = let
      v124 :: T_Position_v124 
      v124 = \ (T_Position_vIn124 ) -> ( let
         _self = rule3064  ()
         _lhsOself :: Position
         _lhsOself = rule3065 _self
         __result_ = T_Position_vOut124 _lhsOself
         in __result_ )
     in C_Position_s125 v124
   {-# INLINE rule3064 #-}
   rule3064 = \  (_ :: ()) ->
     Position_Unknown
   {-# INLINE rule3065 #-}
   rule3065 = \ _self ->
     _self

-- Qualifier ---------------------------------------------------
-- wrapper
data Inh_Qualifier  = Inh_Qualifier { allPatterns_Inh_Qualifier :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Qualifier :: (M.Map NameWithRange TpScheme), assumptions_Inh_Qualifier :: (Assumptions), availablePredicates_Inh_Qualifier :: (Predicates), betaUnique_Inh_Qualifier :: (Int), classEnvironment_Inh_Qualifier :: (ClassEnvironment), collectErrors_Inh_Qualifier :: (TypeErrors), collectWarnings_Inh_Qualifier :: (Warnings), constraints_Inh_Qualifier :: (ConstraintSet), counter_Inh_Qualifier :: (Int), currentChunk_Inh_Qualifier :: (Int), dictionaryEnvironment_Inh_Qualifier :: (DictionaryEnvironment), importEnvironment_Inh_Qualifier :: (ImportEnvironment), matchIO_Inh_Qualifier :: (IO ()), monos_Inh_Qualifier :: (Monos), namesInScope_Inh_Qualifier :: (Names), orderedTypeSynonyms_Inh_Qualifier :: (OrderedTypeSynonyms), parentTree_Inh_Qualifier :: (InfoTree), patternMatchWarnings_Inh_Qualifier :: ([Warning]), substitution_Inh_Qualifier :: (FixpointSubstitution), typeschemeMap_Inh_Qualifier :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Qualifier :: (Names), uniqueChunk_Inh_Qualifier :: (Int), uniqueSecondRound_Inh_Qualifier :: (Int) }
data Syn_Qualifier  = Syn_Qualifier { assumptions_Syn_Qualifier :: (Assumptions), betaUnique_Syn_Qualifier :: (Int), collectErrors_Syn_Qualifier :: (TypeErrors), collectInstances_Syn_Qualifier :: ([(Name, Instance)]), collectWarnings_Syn_Qualifier :: (Warnings), constraints_Syn_Qualifier :: (ConstraintSet), counter_Syn_Qualifier :: (Int), dictionaryEnvironment_Syn_Qualifier :: (DictionaryEnvironment), infoTree_Syn_Qualifier :: (InfoTree), matchIO_Syn_Qualifier :: (IO ()), monos_Syn_Qualifier :: (Monos), namesInScope_Syn_Qualifier :: (Names), patternMatchWarnings_Syn_Qualifier :: ([Warning]), self_Syn_Qualifier :: (Qualifier), unboundNames_Syn_Qualifier :: (Names), uniqueChunk_Syn_Qualifier :: (Int), uniqueSecondRound_Syn_Qualifier :: (Int) }
{-# INLINABLE wrap_Qualifier #-}
wrap_Qualifier :: T_Qualifier  -> Inh_Qualifier  -> (Syn_Qualifier )
wrap_Qualifier (T_Qualifier act) (Inh_Qualifier _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Qualifier_s128 sem arg)
        return (Syn_Qualifier _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_Qualifier #-}
sem_Qualifier :: Qualifier  -> T_Qualifier 
sem_Qualifier ( Qualifier_Guard range_ guard_ ) = sem_Qualifier_Guard ( sem_Range range_ ) ( sem_Expression guard_ )
sem_Qualifier ( Qualifier_Let range_ declarations_ ) = sem_Qualifier_Let ( sem_Range range_ ) ( sem_Declarations declarations_ )
sem_Qualifier ( Qualifier_Generator range_ pattern_ expression_ ) = sem_Qualifier_Generator ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_Expression expression_ )
sem_Qualifier ( Qualifier_Empty range_ ) = sem_Qualifier_Empty ( sem_Range range_ )

-- semantic domain
newtype T_Qualifier  = T_Qualifier {
                                   attach_T_Qualifier :: Identity (T_Qualifier_s128 )
                                   }
newtype T_Qualifier_s128  = C_Qualifier_s128 {
                                             inv_Qualifier_s128 :: (T_Qualifier_v127 )
                                             }
data T_Qualifier_s129  = C_Qualifier_s129
type T_Qualifier_v127  = (T_Qualifier_vIn127 ) -> (T_Qualifier_vOut127 )
data T_Qualifier_vIn127  = T_Qualifier_vIn127 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Qualifier_vOut127  = T_Qualifier_vOut127 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTree) (IO ()) (Monos) (Names) ([Warning]) (Qualifier) (Names) (Int) (Int)
{-# NOINLINE sem_Qualifier_Guard #-}
sem_Qualifier_Guard :: T_Range  -> T_Expression  -> T_Qualifier 
sem_Qualifier_Guard arg_range_ arg_guard_ = T_Qualifier (return st128) where
   {-# NOINLINE st128 #-}
   st128 = let
      v127 :: T_Qualifier_v127 
      v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _guardX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_guard_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _guardIassumptions _guardIbeta _guardIbetaUnique _guardIcollectErrors _guardIcollectInstances _guardIcollectWarnings _guardIconstraints _guardIcounter _guardIdictionaryEnvironment _guardIinfoTree _guardImatchIO _guardImatches _guardIpatternMatchWarnings _guardIself _guardIunboundNames _guardIuniqueChunk _guardIuniqueSecondRound) = inv_Expression_s41 _guardX41 (T_Expression_vIn40 _guardOallPatterns _guardOallTypeSchemes _guardOavailablePredicates _guardObetaUnique _guardOclassEnvironment _guardOcollectErrors _guardOcollectWarnings _guardOcounter _guardOcurrentChunk _guardOdictionaryEnvironment _guardOimportEnvironment _guardOmatchIO _guardOmonos _guardOnamesInScope _guardOorderedTypeSynonyms _guardOparentTree _guardOpatternMatchWarnings _guardOsubstitution _guardOtryPatterns _guardOtypeschemeMap _guardOuniqueChunk _guardOuniqueSecondRound)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3066 _guardIassumptions _lhsIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3067 _locConstraints
         _locConstraints = rule3068 _guardIconstraints _lhsIconstraints _newcon
         _newcon = rule3069 _cinfo _guardIbeta
         _cinfo = rule3070 _parentTree
         _localInfo = rule3071 _lhsImonos _self
         _parentTree = rule3072 _guardIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3073 _parentTree
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3074 _guardIunboundNames _lhsIunboundNames
         _guardOtryPatterns = rule3075  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3076 _guardIcollectInstances
         _self = rule3077 _guardIself _rangeIself
         _lhsOself :: Qualifier
         _lhsOself = rule3078 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3079 _guardIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3080 _guardIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3081 _guardIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3082 _guardIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3083 _guardIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3084 _guardImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3085 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3086 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3087 _guardIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3088 _guardIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3089 _guardIuniqueSecondRound
         _guardOallPatterns = rule3090 _lhsIallPatterns
         _guardOallTypeSchemes = rule3091 _lhsIallTypeSchemes
         _guardOavailablePredicates = rule3092 _lhsIavailablePredicates
         _guardObetaUnique = rule3093 _lhsIbetaUnique
         _guardOclassEnvironment = rule3094 _lhsIclassEnvironment
         _guardOcollectErrors = rule3095 _lhsIcollectErrors
         _guardOcollectWarnings = rule3096 _lhsIcollectWarnings
         _guardOcounter = rule3097 _lhsIcounter
         _guardOcurrentChunk = rule3098 _lhsIcurrentChunk
         _guardOdictionaryEnvironment = rule3099 _lhsIdictionaryEnvironment
         _guardOimportEnvironment = rule3100 _lhsIimportEnvironment
         _guardOmatchIO = rule3101 _lhsImatchIO
         _guardOmonos = rule3102 _lhsImonos
         _guardOnamesInScope = rule3103 _lhsInamesInScope
         _guardOorderedTypeSynonyms = rule3104 _lhsIorderedTypeSynonyms
         _guardOparentTree = rule3105 _parentTree
         _guardOpatternMatchWarnings = rule3106 _lhsIpatternMatchWarnings
         _guardOsubstitution = rule3107 _lhsIsubstitution
         _guardOtypeschemeMap = rule3108 _lhsItypeschemeMap
         _guardOuniqueChunk = rule3109 _lhsIuniqueChunk
         _guardOuniqueSecondRound = rule3110 _lhsIuniqueSecondRound
         __result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Qualifier_s128 v127
   {-# INLINE rule3066 #-}
   rule3066 = \ ((_guardIassumptions) :: Assumptions) ((_lhsIassumptions) :: Assumptions) ->
                            _lhsIassumptions `combine` _guardIassumptions
   {-# INLINE rule3067 #-}
   rule3067 = \ _locConstraints ->
                            _locConstraints
   {-# INLINE rule3068 #-}
   rule3068 = \ ((_guardIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ->
                               Node [ _newcon .<. _guardIconstraints
                                    , _lhsIconstraints
                                    ]
   {-# INLINE rule3069 #-}
   rule3069 = \ _cinfo ((_guardIbeta) :: Tp) ->
                            [ (_guardIbeta .==. boolType) _cinfo ]
   {-# INLINE rule3070 #-}
   rule3070 = \ _parentTree ->
     orphanConstraint 0 "boolean qualifier" _parentTree
        []
   {-# INLINE rule3071 #-}
   rule3071 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Qual _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3072 #-}
   rule3072 = \ ((_guardIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_guardIinfoTree]
   {-# INLINE rule3073 #-}
   rule3073 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3074 #-}
   rule3074 = \ ((_guardIunboundNames) :: Names) ((_lhsIunboundNames) :: Names) ->
                                              _guardIunboundNames ++ _lhsIunboundNames
   {-# INLINE rule3075 #-}
   rule3075 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule3076 #-}
   rule3076 = \ ((_guardIcollectInstances) :: [(Name, Instance)]) ->
     _guardIcollectInstances
   {-# INLINE rule3077 #-}
   rule3077 = \ ((_guardIself) :: Expression) ((_rangeIself) :: Range) ->
     Qualifier_Guard _rangeIself _guardIself
   {-# INLINE rule3078 #-}
   rule3078 = \ _self ->
     _self
   {-# INLINE rule3079 #-}
   rule3079 = \ ((_guardIbetaUnique) :: Int) ->
     _guardIbetaUnique
   {-# INLINE rule3080 #-}
   rule3080 = \ ((_guardIcollectErrors) :: TypeErrors) ->
     _guardIcollectErrors
   {-# INLINE rule3081 #-}
   rule3081 = \ ((_guardIcollectWarnings) :: Warnings) ->
     _guardIcollectWarnings
   {-# INLINE rule3082 #-}
   rule3082 = \ ((_guardIcounter) :: Int) ->
     _guardIcounter
   {-# INLINE rule3083 #-}
   rule3083 = \ ((_guardIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _guardIdictionaryEnvironment
   {-# INLINE rule3084 #-}
   rule3084 = \ ((_guardImatchIO) :: IO ()) ->
     _guardImatchIO
   {-# INLINE rule3085 #-}
   rule3085 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3086 #-}
   rule3086 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3087 #-}
   rule3087 = \ ((_guardIpatternMatchWarnings) :: [Warning]) ->
     _guardIpatternMatchWarnings
   {-# INLINE rule3088 #-}
   rule3088 = \ ((_guardIuniqueChunk) :: Int) ->
     _guardIuniqueChunk
   {-# INLINE rule3089 #-}
   rule3089 = \ ((_guardIuniqueSecondRound) :: Int) ->
     _guardIuniqueSecondRound
   {-# INLINE rule3090 #-}
   rule3090 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3091 #-}
   rule3091 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3092 #-}
   rule3092 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3093 #-}
   rule3093 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3094 #-}
   rule3094 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3095 #-}
   rule3095 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3096 #-}
   rule3096 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3097 #-}
   rule3097 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3098 #-}
   rule3098 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3099 #-}
   rule3099 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3100 #-}
   rule3100 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3101 #-}
   rule3101 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3102 #-}
   rule3102 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3103 #-}
   rule3103 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3104 #-}
   rule3104 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3105 #-}
   rule3105 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3106 #-}
   rule3106 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3107 #-}
   rule3107 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3108 #-}
   rule3108 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3109 #-}
   rule3109 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3110 #-}
   rule3110 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Qualifier_Let #-}
sem_Qualifier_Let :: T_Range  -> T_Declarations  -> T_Qualifier 
sem_Qualifier_Let arg_range_ arg_declarations_ = T_Qualifier (return st128) where
   {-# NOINLINE st128 #-}
   st128 = let
      v127 :: T_Qualifier_v127 
      v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
         _declarationsObindingGroups = rule3111  ()
         _lhsOassumptions :: Assumptions
         _lhsOconstraints :: ConstraintSet
         _lhsObetaUnique :: Int
         (_lhsOassumptions,_lhsOconstraints,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule3112 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIassumptions _lhsIconstraints _lhsIcurrentChunk _lhsImonos
         _inferredTypes = rule3113 _implicitsFM _lhsItypeschemeMap
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3114 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3115 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
         _allTypeSchemes = rule3116 _lhsIallTypeSchemes _localTypes
         _localTypes = rule3117 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
         _declarationsOtypeSignatures = rule3118  ()
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3119 _chunkNr
         _localInfo = rule3120 _lhsImonos _self
         _declInfo = rule3121 _declarationsIself _lhsImonos
         _thisTree = rule3122 _declTree _lhsIparentTree _localInfo
         _declTree = rule3123 _declInfo _declarationsIinfoTrees _thisTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3124 _thisTree
         _declarationsOparentTree = rule3125 _declTree
         (_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule3126  ()
         (_namesInScope,_unboundNames,_scopeInfo) = rule3127 _declarationsIdeclVarNames _declarationsIunboundNames _lhsInamesInScope _lhsIunboundNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3128 _unboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3129 _declarationsIcollectInstances
         _self = rule3130 _declarationsIself _rangeIself
         _lhsOself :: Qualifier
         _lhsOself = rule3131 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule3132 _declarationsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3133 _declarationsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3134 _declarationsImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3135 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3136 _namesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3137 _declarationsIpatternMatchWarnings
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3138 _lhsIuniqueSecondRound
         _declarationsOallPatterns = rule3139 _lhsIallPatterns
         _declarationsOallTypeSchemes = rule3140 _allTypeSchemes
         _declarationsOavailablePredicates = rule3141 _lhsIavailablePredicates
         _declarationsObetaUnique = rule3142 _lhsIbetaUnique
         _declarationsOclassEnvironment = rule3143 _lhsIclassEnvironment
         _declarationsOcollectErrors = rule3144 _lhsIcollectErrors
         _declarationsOcollectWarnings = rule3145 _lhsIcollectWarnings
         _declarationsOcounter = rule3146 _lhsIcounter
         _declarationsOcurrentChunk = rule3147 _lhsIcurrentChunk
         _declarationsOdictionaryEnvironment = rule3148 _lhsIdictionaryEnvironment
         _declarationsOimportEnvironment = rule3149 _lhsIimportEnvironment
         _declarationsOinheritedBDG = rule3150 _inheritedBDG
         _declarationsOmatchIO = rule3151 _lhsImatchIO
         _declarationsOmonos = rule3152 _lhsImonos
         _declarationsOnamesInScope = rule3153 _namesInScope
         _declarationsOorderedTypeSynonyms = rule3154 _lhsIorderedTypeSynonyms
         _declarationsOpatternMatchWarnings = rule3155 _lhsIpatternMatchWarnings
         _declarationsOsubstitution = rule3156 _lhsIsubstitution
         _declarationsOtypeschemeMap = rule3157 _lhsItypeschemeMap
         _declarationsOuniqueChunk = rule3158 _lhsIuniqueChunk
         __result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Qualifier_s128 v127
   {-# INLINE rule3111 #-}
   rule3111 = \  (_ :: ()) ->
                                            []
   {-# INLINE rule3112 #-}
   rule3112 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIassumptions) :: Assumptions) ((_lhsIconstraints) :: ConstraintSet) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
               let inputBDG   = (False, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _declarationsIbetaUnique)
                   mybdggroup = Just (_lhsIassumptions, [_lhsIconstraints])
               in performBindingGroup inputBDG _declarationsIbindingGroups
   {-# INLINE rule3113 #-}
   rule3113 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
                                        findInferredTypes _lhsItypeschemeMap _implicitsFM
   {-# INLINE rule3114 #-}
   rule3114 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
                                        missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
                                        ++ _declarationsIcollectWarnings
   {-# INLINE rule3115 #-}
   rule3115 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
                                        restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
                                        ++ _declarationsIcollectErrors
   {-# INLINE rule3116 #-}
   rule3116 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
                                    _localTypes `M.union` _lhsIallTypeSchemes
   {-# INLINE rule3117 #-}
   rule3117 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
                                    makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
   {-# INLINE rule3118 #-}
   rule3118 = \  (_ :: ()) ->
                                                                  M.empty
   {-# INLINE rule3119 #-}
   rule3119 = \ _chunkNr ->
                                                     _chunkNr
   {-# INLINE rule3120 #-}
   rule3120 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Qual _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3121 #-}
   rule3121 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
                          LocalInfo { self = UHA_Decls _declarationsIself
                                    , assignedType = Nothing
                                    , monos = _lhsImonos
                                    }
   {-# INLINE rule3122 #-}
   rule3122 = \ _declTree ((_lhsIparentTree) :: InfoTree) _localInfo ->
                          node _lhsIparentTree _localInfo [_declTree]
   {-# INLINE rule3123 #-}
   rule3123 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) _thisTree ->
                          node _thisTree _declInfo _declarationsIinfoTrees
   {-# INLINE rule3124 #-}
   rule3124 = \ _thisTree ->
                          _thisTree
   {-# INLINE rule3125 #-}
   rule3125 = \ _declTree ->
                                     _declTree
   {-# INLINE rule3126 #-}
   rule3126 = \  (_ :: ()) ->
                                                                                                                                                   internalError "PartialSyntax.ag" "n/a" "toplevel Qualifier"
   {-# INLINE rule3127 #-}
   rule3127 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ->
                                                             changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
   {-# INLINE rule3128 #-}
   rule3128 = \ _unboundNames ->
                                              _unboundNames
   {-# INLINE rule3129 #-}
   rule3129 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
     _declarationsIcollectInstances
   {-# INLINE rule3130 #-}
   rule3130 = \ ((_declarationsIself) :: Declarations) ((_rangeIself) :: Range) ->
     Qualifier_Let _rangeIself _declarationsIself
   {-# INLINE rule3131 #-}
   rule3131 = \ _self ->
     _self
   {-# INLINE rule3132 #-}
   rule3132 = \ ((_declarationsIcounter) :: Int) ->
     _declarationsIcounter
   {-# INLINE rule3133 #-}
   rule3133 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _declarationsIdictionaryEnvironment
   {-# INLINE rule3134 #-}
   rule3134 = \ ((_declarationsImatchIO) :: IO ()) ->
     _declarationsImatchIO
   {-# INLINE rule3135 #-}
   rule3135 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3136 #-}
   rule3136 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule3137 #-}
   rule3137 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
     _declarationsIpatternMatchWarnings
   {-# INLINE rule3138 #-}
   rule3138 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule3139 #-}
   rule3139 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3140 #-}
   rule3140 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule3141 #-}
   rule3141 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3142 #-}
   rule3142 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3143 #-}
   rule3143 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3144 #-}
   rule3144 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3145 #-}
   rule3145 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3146 #-}
   rule3146 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3147 #-}
   rule3147 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3148 #-}
   rule3148 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3149 #-}
   rule3149 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3150 #-}
   rule3150 = \ _inheritedBDG ->
     _inheritedBDG
   {-# INLINE rule3151 #-}
   rule3151 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3152 #-}
   rule3152 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3153 #-}
   rule3153 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule3154 #-}
   rule3154 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3155 #-}
   rule3155 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3156 #-}
   rule3156 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3157 #-}
   rule3157 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3158 #-}
   rule3158 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Qualifier_Generator #-}
sem_Qualifier_Generator :: T_Range  -> T_Pattern  -> T_Expression  -> T_Qualifier 
sem_Qualifier_Generator arg_range_ arg_pattern_ arg_expression_ = T_Qualifier (return st128) where
   {-# NOINLINE st128 #-}
   st128 = let
      v127 :: T_Qualifier_v127 
      v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3159 _assumptions' _expressionIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3160 _locConstraints
         _lhsOmonos :: Monos
         _lhsOmonos = rule3161 _csetBinds _lhsImonos _patternIenvironment
         _locConstraints = rule3162 _csetBinds _expressionIconstraints _lhsIconstraints _newcon _patternIconstraints
         (_csetBinds,_assumptions') = rule3163 _cinfoBind _lhsIassumptions _patternIenvironment
         _newcon = rule3164 _cinfoResult _expressionIbeta _patternIbeta
         _cinfoResult = rule3165 _parentTree
         _cinfoBind = rule3166 _parentTree _patternIenvironment
         _localInfo = rule3167 _lhsImonos _self
         _parentTree = rule3168 _expressionIinfoTree _lhsIparentTree _localInfo _patternIinfoTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3169 _parentTree
         (_namesInScope,_unboundNames,_scopeInfo) = rule3170 _expressionIunboundNames _lhsInamesInScope _lhsIunboundNames _patternIpatVarNames
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3171 _namesInScope
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3172 _unboundNames
         _expressionOnamesInScope = rule3173 _lhsInamesInScope
         _expressionOtryPatterns = rule3174  ()
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3175 _expressionIpatternMatchWarnings _lhsIimportEnvironment _lhsIsubstitution _patternIbeta _patternIelements _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3176 _expressionIcollectInstances
         _self = rule3177 _expressionIself _patternIself _rangeIself
         _lhsOself :: Qualifier
         _lhsOself = rule3178 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3179 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3180 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3181 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3182 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3183 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3184 _expressionImatchIO
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3185 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3186 _expressionIuniqueSecondRound
         _patternObetaUnique = rule3187 _lhsIbetaUnique
         _patternOcounter = rule3188 _lhsIcounter
         _patternOimportEnvironment = rule3189 _lhsIimportEnvironment
         _patternOmonos = rule3190 _lhsImonos
         _patternOnamesInScope = rule3191 _namesInScope
         _patternOparentTree = rule3192 _parentTree
         _patternOpatternMatchWarnings = rule3193 _lhsIpatternMatchWarnings
         _expressionOallPatterns = rule3194 _lhsIallPatterns
         _expressionOallTypeSchemes = rule3195 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule3196 _lhsIavailablePredicates
         _expressionObetaUnique = rule3197 _patternIbetaUnique
         _expressionOclassEnvironment = rule3198 _lhsIclassEnvironment
         _expressionOcollectErrors = rule3199 _lhsIcollectErrors
         _expressionOcollectWarnings = rule3200 _lhsIcollectWarnings
         _expressionOcounter = rule3201 _patternIcounter
         _expressionOcurrentChunk = rule3202 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule3203 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule3204 _lhsIimportEnvironment
         _expressionOmatchIO = rule3205 _lhsImatchIO
         _expressionOmonos = rule3206 _lhsImonos
         _expressionOorderedTypeSynonyms = rule3207 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule3208 _parentTree
         _expressionOpatternMatchWarnings = rule3209 _patternIpatternMatchWarnings
         _expressionOsubstitution = rule3210 _lhsIsubstitution
         _expressionOtypeschemeMap = rule3211 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule3212 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule3213 _lhsIuniqueSecondRound
         __result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Qualifier_s128 v127
   {-# INLINE rule3159 #-}
   rule3159 = \ _assumptions' ((_expressionIassumptions) :: Assumptions) ->
                            _assumptions' `combine` _expressionIassumptions
   {-# INLINE rule3160 #-}
   rule3160 = \ _locConstraints ->
                            _locConstraints
   {-# INLINE rule3161 #-}
   rule3161 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
                            M.elems _patternIenvironment ++ getMonos _csetBinds ++ _lhsImonos
   {-# INLINE rule3162 #-}
   rule3162 = \ _csetBinds ((_expressionIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ((_patternIconstraints) :: ConstraintSet) ->
                               _newcon .>. _csetBinds .>>.
                                  Node [ _patternIconstraints
                                       , _expressionIconstraints
                                       , _lhsIconstraints
                                       ]
   {-# INLINE rule3163 #-}
   rule3163 = \ _cinfoBind ((_lhsIassumptions) :: Assumptions) ((_patternIenvironment) :: PatternAssumptions) ->
                                         (_patternIenvironment .===. _lhsIassumptions) _cinfoBind
   {-# INLINE rule3164 #-}
   rule3164 = \ _cinfoResult ((_expressionIbeta) :: Tp) ((_patternIbeta) :: Tp) ->
                            [ (_expressionIbeta .==. listType _patternIbeta) _cinfoResult ]
   {-# INLINE rule3165 #-}
   rule3165 = \ _parentTree ->
     childConstraint 1 "generator" _parentTree
        []
   {-# INLINE rule3166 #-}
   rule3166 = \ _parentTree ((_patternIenvironment) :: PatternAssumptions) ->
     \name -> variableConstraint "variable" (nameToUHA_Expr name)
        [ FolkloreConstraint
        , makeUnifier name "generator" _patternIenvironment _parentTree
        ]
   {-# INLINE rule3167 #-}
   rule3167 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Qual _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3168 #-}
   rule3168 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ->
                            node _lhsIparentTree _localInfo [_patternIinfoTree, _expressionIinfoTree]
   {-# INLINE rule3169 #-}
   rule3169 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3170 #-}
   rule3170 = \ ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ((_patternIpatVarNames) :: Names) ->
                                                                        changeOfScope _patternIpatVarNames (_expressionIunboundNames  ++ _lhsIunboundNames)  _lhsInamesInScope
   {-# INLINE rule3171 #-}
   rule3171 = \ _namesInScope ->
                                              _namesInScope
   {-# INLINE rule3172 #-}
   rule3172 = \ _unboundNames ->
                                              _unboundNames
   {-# INLINE rule3173 #-}
   rule3173 = \ ((_lhsInamesInScope) :: Names) ->
                                              _lhsInamesInScope
   {-# INLINE rule3174 #-}
   rule3174 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule3175 #-}
   rule3175 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIbeta) :: Tp) ((_patternIelements) ::   [PatternElement]        ) ((_rangeIself) :: Range) ->
                                                    patternMatchWarnings _lhsIimportEnvironment
                                                                         _lhsIsubstitution
                                                                         _patternIbeta
                                                                         (:[])
                                                                         [(_patternIelements, False)]
                                                                         _rangeIself
                                                                         Nothing
                                                                         False
                                                                         []
                                                                         "generator"
                                                                         "<-"
                                                    ++ _expressionIpatternMatchWarnings
   {-# INLINE rule3176 #-}
   rule3176 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule3177 #-}
   rule3177 = \ ((_expressionIself) :: Expression) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
     Qualifier_Generator _rangeIself _patternIself _expressionIself
   {-# INLINE rule3178 #-}
   rule3178 = \ _self ->
     _self
   {-# INLINE rule3179 #-}
   rule3179 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule3180 #-}
   rule3180 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule3181 #-}
   rule3181 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule3182 #-}
   rule3182 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule3183 #-}
   rule3183 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule3184 #-}
   rule3184 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule3185 #-}
   rule3185 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule3186 #-}
   rule3186 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule3187 #-}
   rule3187 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3188 #-}
   rule3188 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3189 #-}
   rule3189 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3190 #-}
   rule3190 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3191 #-}
   rule3191 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule3192 #-}
   rule3192 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3193 #-}
   rule3193 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3194 #-}
   rule3194 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3195 #-}
   rule3195 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3196 #-}
   rule3196 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3197 #-}
   rule3197 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule3198 #-}
   rule3198 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3199 #-}
   rule3199 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3200 #-}
   rule3200 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3201 #-}
   rule3201 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule3202 #-}
   rule3202 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3203 #-}
   rule3203 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3204 #-}
   rule3204 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3205 #-}
   rule3205 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3206 #-}
   rule3206 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3207 #-}
   rule3207 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3208 #-}
   rule3208 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3209 #-}
   rule3209 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule3210 #-}
   rule3210 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3211 #-}
   rule3211 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3212 #-}
   rule3212 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3213 #-}
   rule3213 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Qualifier_Empty #-}
sem_Qualifier_Empty :: T_Range  -> T_Qualifier 
sem_Qualifier_Empty arg_range_ = T_Qualifier (return st128) where
   {-# NOINLINE st128 #-}
   st128 = let
      v127 :: T_Qualifier_v127 
      v127 = \ (T_Qualifier_vIn127 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _localInfo = rule3214 _lhsImonos _self
         _parentTree = rule3215 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3216 _parentTree
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3217  ()
         _self = rule3218 _rangeIself
         _lhsOself :: Qualifier
         _lhsOself = rule3219 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3220 _lhsIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3221 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3222 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3223 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3224 _lhsIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule3225 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3226 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3227 _lhsImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3228 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3229 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3230 _lhsIpatternMatchWarnings
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3231 _lhsIunboundNames
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3232 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3233 _lhsIuniqueSecondRound
         __result_ = T_Qualifier_vOut127 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Qualifier_s128 v127
   {-# INLINE rule3214 #-}
   rule3214 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Qual _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3215 #-}
   rule3215 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule3216 #-}
   rule3216 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3217 #-}
   rule3217 = \  (_ :: ()) ->
     []
   {-# INLINE rule3218 #-}
   rule3218 = \ ((_rangeIself) :: Range) ->
     Qualifier_Empty _rangeIself
   {-# INLINE rule3219 #-}
   rule3219 = \ _self ->
     _self
   {-# INLINE rule3220 #-}
   rule3220 = \ ((_lhsIassumptions) :: Assumptions) ->
     _lhsIassumptions
   {-# INLINE rule3221 #-}
   rule3221 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3222 #-}
   rule3222 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3223 #-}
   rule3223 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3224 #-}
   rule3224 = \ ((_lhsIconstraints) :: ConstraintSet) ->
     _lhsIconstraints
   {-# INLINE rule3225 #-}
   rule3225 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3226 #-}
   rule3226 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3227 #-}
   rule3227 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3228 #-}
   rule3228 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3229 #-}
   rule3229 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3230 #-}
   rule3230 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3231 #-}
   rule3231 = \ ((_lhsIunboundNames) :: Names) ->
     _lhsIunboundNames
   {-# INLINE rule3232 #-}
   rule3232 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3233 #-}
   rule3233 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- Qualifiers --------------------------------------------------
-- wrapper
data Inh_Qualifiers  = Inh_Qualifiers { allPatterns_Inh_Qualifiers :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Qualifiers :: (M.Map NameWithRange TpScheme), assumptions_Inh_Qualifiers :: (Assumptions), availablePredicates_Inh_Qualifiers :: (Predicates), betaUnique_Inh_Qualifiers :: (Int), classEnvironment_Inh_Qualifiers :: (ClassEnvironment), collectErrors_Inh_Qualifiers :: (TypeErrors), collectWarnings_Inh_Qualifiers :: (Warnings), constraints_Inh_Qualifiers :: (ConstraintSet), counter_Inh_Qualifiers :: (Int), currentChunk_Inh_Qualifiers :: (Int), dictionaryEnvironment_Inh_Qualifiers :: (DictionaryEnvironment), importEnvironment_Inh_Qualifiers :: (ImportEnvironment), matchIO_Inh_Qualifiers :: (IO ()), monos_Inh_Qualifiers :: (Monos), namesInScope_Inh_Qualifiers :: (Names), orderedTypeSynonyms_Inh_Qualifiers :: (OrderedTypeSynonyms), parentTree_Inh_Qualifiers :: (InfoTree), patternMatchWarnings_Inh_Qualifiers :: ([Warning]), substitution_Inh_Qualifiers :: (FixpointSubstitution), typeschemeMap_Inh_Qualifiers :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Qualifiers :: (Names), uniqueChunk_Inh_Qualifiers :: (Int), uniqueSecondRound_Inh_Qualifiers :: (Int) }
data Syn_Qualifiers  = Syn_Qualifiers { assumptions_Syn_Qualifiers :: (Assumptions), betaUnique_Syn_Qualifiers :: (Int), collectErrors_Syn_Qualifiers :: (TypeErrors), collectInstances_Syn_Qualifiers :: ([(Name, Instance)]), collectWarnings_Syn_Qualifiers :: (Warnings), constraints_Syn_Qualifiers :: (ConstraintSet), counter_Syn_Qualifiers :: (Int), dictionaryEnvironment_Syn_Qualifiers :: (DictionaryEnvironment), infoTrees_Syn_Qualifiers :: (InfoTrees), matchIO_Syn_Qualifiers :: (IO ()), monos_Syn_Qualifiers :: (Monos), namesInScope_Syn_Qualifiers :: (Names), patternMatchWarnings_Syn_Qualifiers :: ([Warning]), self_Syn_Qualifiers :: (Qualifiers), unboundNames_Syn_Qualifiers :: (Names), uniqueChunk_Syn_Qualifiers :: (Int), uniqueSecondRound_Syn_Qualifiers :: (Int) }
{-# INLINABLE wrap_Qualifiers #-}
wrap_Qualifiers :: T_Qualifiers  -> Inh_Qualifiers  -> (Syn_Qualifiers )
wrap_Qualifiers (T_Qualifiers act) (Inh_Qualifiers _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Qualifiers_vIn130 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_Qualifiers_vOut130 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Qualifiers_s131 sem arg)
        return (Syn_Qualifiers _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_Qualifiers #-}
sem_Qualifiers :: Qualifiers  -> T_Qualifiers 
sem_Qualifiers list = Prelude.foldr sem_Qualifiers_Cons sem_Qualifiers_Nil (Prelude.map sem_Qualifier list)

-- semantic domain
newtype T_Qualifiers  = T_Qualifiers {
                                     attach_T_Qualifiers :: Identity (T_Qualifiers_s131 )
                                     }
newtype T_Qualifiers_s131  = C_Qualifiers_s131 {
                                               inv_Qualifiers_s131 :: (T_Qualifiers_v130 )
                                               }
data T_Qualifiers_s132  = C_Qualifiers_s132
type T_Qualifiers_v130  = (T_Qualifiers_vIn130 ) -> (T_Qualifiers_vOut130 )
data T_Qualifiers_vIn130  = T_Qualifiers_vIn130 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Qualifiers_vOut130  = T_Qualifiers_vOut130 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (InfoTrees) (IO ()) (Monos) (Names) ([Warning]) (Qualifiers) (Names) (Int) (Int)
{-# NOINLINE sem_Qualifiers_Cons #-}
sem_Qualifiers_Cons :: T_Qualifier  -> T_Qualifiers  -> T_Qualifiers 
sem_Qualifiers_Cons arg_hd_ arg_tl_ = T_Qualifiers (return st131) where
   {-# NOINLINE st131 #-}
   st131 = let
      v130 :: T_Qualifiers_v130 
      v130 = \ (T_Qualifiers_vIn130 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _hdX128 = Control.Monad.Identity.runIdentity (attach_T_Qualifier (arg_hd_))
         _tlX131 = Control.Monad.Identity.runIdentity (attach_T_Qualifiers (arg_tl_))
         (T_Qualifier_vOut127 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIinfoTree _hdImatchIO _hdImonos _hdInamesInScope _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound) = inv_Qualifier_s128 _hdX128 (T_Qualifier_vIn127 _hdOallPatterns _hdOallTypeSchemes _hdOassumptions _hdOavailablePredicates _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOconstraints _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOunboundNames _hdOuniqueChunk _hdOuniqueSecondRound)
         (T_Qualifiers_vOut130 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraints _tlIcounter _tlIdictionaryEnvironment _tlIinfoTrees _tlImatchIO _tlImonos _tlInamesInScope _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_Qualifiers_s131 _tlX131 (T_Qualifiers_vIn130 _tlOallPatterns _tlOallTypeSchemes _tlOassumptions _tlOavailablePredicates _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOconstraints _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOunboundNames _tlOuniqueChunk _tlOuniqueSecondRound)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3234 _hdIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3235 _hdIconstraints
         _hdOassumptions = rule3236 _tlIassumptions
         _hdOconstraints = rule3237 _tlIconstraints
         _tlOassumptions = rule3238 _lhsIassumptions
         _tlOconstraints = rule3239 _lhsIconstraints
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule3240 _hdIinfoTree _tlIinfoTrees
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3241 _hdIunboundNames
         _tlOunboundNames = rule3242 _lhsIunboundNames
         _hdOunboundNames = rule3243 _tlIunboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3244 _hdIcollectInstances _tlIcollectInstances
         _self = rule3245 _hdIself _tlIself
         _lhsOself :: Qualifiers
         _lhsOself = rule3246 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3247 _tlIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3248 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3249 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3250 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3251 _tlIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3252 _tlImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3253 _tlImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3254 _tlInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3255 _tlIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3256 _tlIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3257 _tlIuniqueSecondRound
         _hdOallPatterns = rule3258 _lhsIallPatterns
         _hdOallTypeSchemes = rule3259 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule3260 _lhsIavailablePredicates
         _hdObetaUnique = rule3261 _lhsIbetaUnique
         _hdOclassEnvironment = rule3262 _lhsIclassEnvironment
         _hdOcollectErrors = rule3263 _lhsIcollectErrors
         _hdOcollectWarnings = rule3264 _lhsIcollectWarnings
         _hdOcounter = rule3265 _lhsIcounter
         _hdOcurrentChunk = rule3266 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule3267 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule3268 _lhsIimportEnvironment
         _hdOmatchIO = rule3269 _lhsImatchIO
         _hdOmonos = rule3270 _lhsImonos
         _hdOnamesInScope = rule3271 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule3272 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule3273 _lhsIparentTree
         _hdOpatternMatchWarnings = rule3274 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule3275 _lhsIsubstitution
         _hdOtypeschemeMap = rule3276 _lhsItypeschemeMap
         _hdOuniqueChunk = rule3277 _lhsIuniqueChunk
         _hdOuniqueSecondRound = rule3278 _lhsIuniqueSecondRound
         _tlOallPatterns = rule3279 _lhsIallPatterns
         _tlOallTypeSchemes = rule3280 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule3281 _lhsIavailablePredicates
         _tlObetaUnique = rule3282 _hdIbetaUnique
         _tlOclassEnvironment = rule3283 _lhsIclassEnvironment
         _tlOcollectErrors = rule3284 _hdIcollectErrors
         _tlOcollectWarnings = rule3285 _hdIcollectWarnings
         _tlOcounter = rule3286 _hdIcounter
         _tlOcurrentChunk = rule3287 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule3288 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule3289 _lhsIimportEnvironment
         _tlOmatchIO = rule3290 _hdImatchIO
         _tlOmonos = rule3291 _hdImonos
         _tlOnamesInScope = rule3292 _hdInamesInScope
         _tlOorderedTypeSynonyms = rule3293 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule3294 _lhsIparentTree
         _tlOpatternMatchWarnings = rule3295 _hdIpatternMatchWarnings
         _tlOsubstitution = rule3296 _lhsIsubstitution
         _tlOtypeschemeMap = rule3297 _lhsItypeschemeMap
         _tlOuniqueChunk = rule3298 _hdIuniqueChunk
         _tlOuniqueSecondRound = rule3299 _hdIuniqueSecondRound
         __result_ = T_Qualifiers_vOut130 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Qualifiers_s131 v130
   {-# INLINE rule3234 #-}
   rule3234 = \ ((_hdIassumptions) :: Assumptions) ->
                            _hdIassumptions
   {-# INLINE rule3235 #-}
   rule3235 = \ ((_hdIconstraints) :: ConstraintSet) ->
                            _hdIconstraints
   {-# INLINE rule3236 #-}
   rule3236 = \ ((_tlIassumptions) :: Assumptions) ->
                            _tlIassumptions
   {-# INLINE rule3237 #-}
   rule3237 = \ ((_tlIconstraints) :: ConstraintSet) ->
                            _tlIconstraints
   {-# INLINE rule3238 #-}
   rule3238 = \ ((_lhsIassumptions) :: Assumptions) ->
                            _lhsIassumptions
   {-# INLINE rule3239 #-}
   rule3239 = \ ((_lhsIconstraints) :: ConstraintSet) ->
                            _lhsIconstraints
   {-# INLINE rule3240 #-}
   rule3240 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTree : _tlIinfoTrees
   {-# INLINE rule3241 #-}
   rule3241 = \ ((_hdIunboundNames) :: Names) ->
                                  _hdIunboundNames
   {-# INLINE rule3242 #-}
   rule3242 = \ ((_lhsIunboundNames) :: Names) ->
                                  _lhsIunboundNames
   {-# INLINE rule3243 #-}
   rule3243 = \ ((_tlIunboundNames) :: Names) ->
                                  _tlIunboundNames
   {-# INLINE rule3244 #-}
   rule3244 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule3245 #-}
   rule3245 = \ ((_hdIself) :: Qualifier) ((_tlIself) :: Qualifiers) ->
     (:) _hdIself _tlIself
   {-# INLINE rule3246 #-}
   rule3246 = \ _self ->
     _self
   {-# INLINE rule3247 #-}
   rule3247 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule3248 #-}
   rule3248 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule3249 #-}
   rule3249 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule3250 #-}
   rule3250 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule3251 #-}
   rule3251 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule3252 #-}
   rule3252 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule3253 #-}
   rule3253 = \ ((_tlImonos) :: Monos) ->
     _tlImonos
   {-# INLINE rule3254 #-}
   rule3254 = \ ((_tlInamesInScope) :: Names) ->
     _tlInamesInScope
   {-# INLINE rule3255 #-}
   rule3255 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule3256 #-}
   rule3256 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule3257 #-}
   rule3257 = \ ((_tlIuniqueSecondRound) :: Int) ->
     _tlIuniqueSecondRound
   {-# INLINE rule3258 #-}
   rule3258 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3259 #-}
   rule3259 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3260 #-}
   rule3260 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3261 #-}
   rule3261 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3262 #-}
   rule3262 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3263 #-}
   rule3263 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3264 #-}
   rule3264 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3265 #-}
   rule3265 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3266 #-}
   rule3266 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3267 #-}
   rule3267 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3268 #-}
   rule3268 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3269 #-}
   rule3269 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3270 #-}
   rule3270 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3271 #-}
   rule3271 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3272 #-}
   rule3272 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3273 #-}
   rule3273 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule3274 #-}
   rule3274 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3275 #-}
   rule3275 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3276 #-}
   rule3276 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3277 #-}
   rule3277 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3278 #-}
   rule3278 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule3279 #-}
   rule3279 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3280 #-}
   rule3280 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3281 #-}
   rule3281 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3282 #-}
   rule3282 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule3283 #-}
   rule3283 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3284 #-}
   rule3284 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule3285 #-}
   rule3285 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule3286 #-}
   rule3286 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule3287 #-}
   rule3287 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3288 #-}
   rule3288 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule3289 #-}
   rule3289 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3290 #-}
   rule3290 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule3291 #-}
   rule3291 = \ ((_hdImonos) :: Monos) ->
     _hdImonos
   {-# INLINE rule3292 #-}
   rule3292 = \ ((_hdInamesInScope) :: Names) ->
     _hdInamesInScope
   {-# INLINE rule3293 #-}
   rule3293 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3294 #-}
   rule3294 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule3295 #-}
   rule3295 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule3296 #-}
   rule3296 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3297 #-}
   rule3297 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3298 #-}
   rule3298 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
   {-# INLINE rule3299 #-}
   rule3299 = \ ((_hdIuniqueSecondRound) :: Int) ->
     _hdIuniqueSecondRound
{-# NOINLINE sem_Qualifiers_Nil #-}
sem_Qualifiers_Nil ::  T_Qualifiers 
sem_Qualifiers_Nil  = T_Qualifiers (return st131) where
   {-# NOINLINE st131 #-}
   st131 = let
      v130 :: T_Qualifiers_v130 
      v130 = \ (T_Qualifiers_vIn130 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule3300  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3301 _lhsIunboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3302  ()
         _self = rule3303  ()
         _lhsOself :: Qualifiers
         _lhsOself = rule3304 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3305 _lhsIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3306 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3307 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3308 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3309 _lhsIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule3310 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3311 _lhsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3312 _lhsImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3313 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3314 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3315 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3316 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3317 _lhsIuniqueSecondRound
         __result_ = T_Qualifiers_vOut130 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOinfoTrees _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Qualifiers_s131 v130
   {-# INLINE rule3300 #-}
   rule3300 = \  (_ :: ()) ->
                               []
   {-# INLINE rule3301 #-}
   rule3301 = \ ((_lhsIunboundNames) :: Names) ->
                                  _lhsIunboundNames
   {-# INLINE rule3302 #-}
   rule3302 = \  (_ :: ()) ->
     []
   {-# INLINE rule3303 #-}
   rule3303 = \  (_ :: ()) ->
     []
   {-# INLINE rule3304 #-}
   rule3304 = \ _self ->
     _self
   {-# INLINE rule3305 #-}
   rule3305 = \ ((_lhsIassumptions) :: Assumptions) ->
     _lhsIassumptions
   {-# INLINE rule3306 #-}
   rule3306 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3307 #-}
   rule3307 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3308 #-}
   rule3308 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3309 #-}
   rule3309 = \ ((_lhsIconstraints) :: ConstraintSet) ->
     _lhsIconstraints
   {-# INLINE rule3310 #-}
   rule3310 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3311 #-}
   rule3311 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3312 #-}
   rule3312 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3313 #-}
   rule3313 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3314 #-}
   rule3314 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3315 #-}
   rule3315 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3316 #-}
   rule3316 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3317 #-}
   rule3317 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- Range -------------------------------------------------------
-- wrapper
data Inh_Range  = Inh_Range {  }
data Syn_Range  = Syn_Range { self_Syn_Range :: (Range) }
{-# INLINABLE wrap_Range #-}
wrap_Range :: T_Range  -> Inh_Range  -> (Syn_Range )
wrap_Range (T_Range act) (Inh_Range ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Range_vIn133 
        (T_Range_vOut133 _lhsOself) <- return (inv_Range_s134 sem arg)
        return (Syn_Range _lhsOself)
   )

-- cata
{-# INLINE sem_Range #-}
sem_Range :: Range  -> T_Range 
sem_Range ( Range_Range start_ stop_ ) = sem_Range_Range ( sem_Position start_ ) ( sem_Position stop_ )

-- semantic domain
newtype T_Range  = T_Range {
                           attach_T_Range :: Identity (T_Range_s134 )
                           }
newtype T_Range_s134  = C_Range_s134 {
                                     inv_Range_s134 :: (T_Range_v133 )
                                     }
data T_Range_s135  = C_Range_s135
type T_Range_v133  = (T_Range_vIn133 ) -> (T_Range_vOut133 )
data T_Range_vIn133  = T_Range_vIn133 
data T_Range_vOut133  = T_Range_vOut133 (Range)
{-# NOINLINE sem_Range_Range #-}
sem_Range_Range :: T_Position  -> T_Position  -> T_Range 
sem_Range_Range arg_start_ arg_stop_ = T_Range (return st134) where
   {-# NOINLINE st134 #-}
   st134 = let
      v133 :: T_Range_v133 
      v133 = \ (T_Range_vIn133 ) -> ( let
         _startX125 = Control.Monad.Identity.runIdentity (attach_T_Position (arg_start_))
         _stopX125 = Control.Monad.Identity.runIdentity (attach_T_Position (arg_stop_))
         (T_Position_vOut124 _startIself) = inv_Position_s125 _startX125 (T_Position_vIn124 )
         (T_Position_vOut124 _stopIself) = inv_Position_s125 _stopX125 (T_Position_vIn124 )
         _self = rule3318 _startIself _stopIself
         _lhsOself :: Range
         _lhsOself = rule3319 _self
         __result_ = T_Range_vOut133 _lhsOself
         in __result_ )
     in C_Range_s134 v133
   {-# INLINE rule3318 #-}
   rule3318 = \ ((_startIself) :: Position) ((_stopIself) :: Position) ->
     Range_Range _startIself _stopIself
   {-# INLINE rule3319 #-}
   rule3319 = \ _self ->
     _self

-- RecordExpressionBinding -------------------------------------
-- wrapper
data Inh_RecordExpressionBinding  = Inh_RecordExpressionBinding { allTypeSchemes_Inh_RecordExpressionBinding :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_RecordExpressionBinding :: (Predicates), classEnvironment_Inh_RecordExpressionBinding :: (ClassEnvironment), collectErrors_Inh_RecordExpressionBinding :: (TypeErrors), collectWarnings_Inh_RecordExpressionBinding :: (Warnings), counter_Inh_RecordExpressionBinding :: (Int), currentChunk_Inh_RecordExpressionBinding :: (Int), dictionaryEnvironment_Inh_RecordExpressionBinding :: (DictionaryEnvironment), importEnvironment_Inh_RecordExpressionBinding :: (ImportEnvironment), namesInScope_Inh_RecordExpressionBinding :: (Names), orderedTypeSynonyms_Inh_RecordExpressionBinding :: (OrderedTypeSynonyms), patternMatchWarnings_Inh_RecordExpressionBinding :: ([Warning]), substitution_Inh_RecordExpressionBinding :: (FixpointSubstitution), typeschemeMap_Inh_RecordExpressionBinding :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_RecordExpressionBinding :: (Int) }
data Syn_RecordExpressionBinding  = Syn_RecordExpressionBinding { collectErrors_Syn_RecordExpressionBinding :: (TypeErrors), collectInstances_Syn_RecordExpressionBinding :: ([(Name, Instance)]), collectWarnings_Syn_RecordExpressionBinding :: (Warnings), counter_Syn_RecordExpressionBinding :: (Int), dictionaryEnvironment_Syn_RecordExpressionBinding :: (DictionaryEnvironment), patternMatchWarnings_Syn_RecordExpressionBinding :: ([Warning]), self_Syn_RecordExpressionBinding :: (RecordExpressionBinding), unboundNames_Syn_RecordExpressionBinding :: (Names), uniqueChunk_Syn_RecordExpressionBinding :: (Int) }
{-# INLINABLE wrap_RecordExpressionBinding #-}
wrap_RecordExpressionBinding :: T_RecordExpressionBinding  -> Inh_RecordExpressionBinding  -> (Syn_RecordExpressionBinding )
wrap_RecordExpressionBinding (T_RecordExpressionBinding act) (Inh_RecordExpressionBinding _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_RecordExpressionBinding_vIn136 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_RecordExpressionBinding_vOut136 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_RecordExpressionBinding_s137 sem arg)
        return (Syn_RecordExpressionBinding _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_RecordExpressionBinding #-}
sem_RecordExpressionBinding :: RecordExpressionBinding  -> T_RecordExpressionBinding 
sem_RecordExpressionBinding ( RecordExpressionBinding_RecordExpressionBinding range_ name_ expression_ ) = sem_RecordExpressionBinding_RecordExpressionBinding ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Expression expression_ )

-- semantic domain
newtype T_RecordExpressionBinding  = T_RecordExpressionBinding {
                                                               attach_T_RecordExpressionBinding :: Identity (T_RecordExpressionBinding_s137 )
                                                               }
newtype T_RecordExpressionBinding_s137  = C_RecordExpressionBinding_s137 {
                                                                         inv_RecordExpressionBinding_s137 :: (T_RecordExpressionBinding_v136 )
                                                                         }
data T_RecordExpressionBinding_s138  = C_RecordExpressionBinding_s138
type T_RecordExpressionBinding_v136  = (T_RecordExpressionBinding_vIn136 ) -> (T_RecordExpressionBinding_vOut136 )
data T_RecordExpressionBinding_vIn136  = T_RecordExpressionBinding_vIn136 (M.Map NameWithRange TpScheme) (Predicates) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (Names) (OrderedTypeSynonyms) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_RecordExpressionBinding_vOut136  = T_RecordExpressionBinding_vOut136 (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (DictionaryEnvironment) ([Warning]) (RecordExpressionBinding) (Names) (Int)
{-# NOINLINE sem_RecordExpressionBinding_RecordExpressionBinding #-}
sem_RecordExpressionBinding_RecordExpressionBinding :: T_Range  -> T_Name  -> T_Expression  -> T_RecordExpressionBinding 
sem_RecordExpressionBinding_RecordExpressionBinding arg_range_ arg_name_ arg_expression_ = T_RecordExpressionBinding (return st137) where
   {-# NOINLINE st137 #-}
   st137 = let
      v136 :: T_RecordExpressionBinding_v136 
      v136 = \ (T_RecordExpressionBinding_vIn136 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _parentTree = rule3320  ()
         (_monos,_constructorenv,_betaUnique,_miscerrors,_warnings,_kindErrors,_valueConstructors,_allValueConstructors,_typeConstructors,_allTypeConstructors,_importEnvironment) = rule3321  ()
         (_allPatterns,_tryPatterns,_matchIO,_uniqueSecondRound) = rule3322  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3323 _expressionIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3324 _expressionIunboundNames
         _self = rule3325 _expressionIself _nameIself _rangeIself
         _lhsOself :: RecordExpressionBinding
         _lhsOself = rule3326 _self
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3327 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3328 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3329 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3330 _expressionIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3331 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3332 _expressionIuniqueChunk
         _expressionOallPatterns = rule3333 _allPatterns
         _expressionOallTypeSchemes = rule3334 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule3335 _lhsIavailablePredicates
         _expressionObetaUnique = rule3336 _betaUnique
         _expressionOclassEnvironment = rule3337 _lhsIclassEnvironment
         _expressionOcollectErrors = rule3338 _lhsIcollectErrors
         _expressionOcollectWarnings = rule3339 _lhsIcollectWarnings
         _expressionOcounter = rule3340 _lhsIcounter
         _expressionOcurrentChunk = rule3341 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule3342 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule3343 _importEnvironment
         _expressionOmatchIO = rule3344 _matchIO
         _expressionOmonos = rule3345 _monos
         _expressionOnamesInScope = rule3346 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule3347 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule3348 _parentTree
         _expressionOpatternMatchWarnings = rule3349 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule3350 _lhsIsubstitution
         _expressionOtryPatterns = rule3351 _tryPatterns
         _expressionOtypeschemeMap = rule3352 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule3353 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule3354 _uniqueSecondRound
         __result_ = T_RecordExpressionBinding_vOut136 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_RecordExpressionBinding_s137 v136
   {-# INLINE rule3320 #-}
   rule3320 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule3321 #-}
   rule3321 = \  (_ :: ()) ->
                                                                                                                                                                                                      internalError "PartialSyntax.ag" "n/a" "RecordExpressionBinding.RecordExpressionBinding"
   {-# INLINE rule3322 #-}
   rule3322 = \  (_ :: ()) ->
                                                                     internalError "TS_PatternMatching.ag" "n/a" "RecordExpressionBinding is not supported"
   {-# INLINE rule3323 #-}
   rule3323 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule3324 #-}
   rule3324 = \ ((_expressionIunboundNames) :: Names) ->
     _expressionIunboundNames
   {-# INLINE rule3325 #-}
   rule3325 = \ ((_expressionIself) :: Expression) ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     RecordExpressionBinding_RecordExpressionBinding _rangeIself _nameIself _expressionIself
   {-# INLINE rule3326 #-}
   rule3326 = \ _self ->
     _self
   {-# INLINE rule3327 #-}
   rule3327 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule3328 #-}
   rule3328 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule3329 #-}
   rule3329 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule3330 #-}
   rule3330 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule3331 #-}
   rule3331 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule3332 #-}
   rule3332 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule3333 #-}
   rule3333 = \ _allPatterns ->
     _allPatterns
   {-# INLINE rule3334 #-}
   rule3334 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3335 #-}
   rule3335 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3336 #-}
   rule3336 = \ _betaUnique ->
     _betaUnique
   {-# INLINE rule3337 #-}
   rule3337 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3338 #-}
   rule3338 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3339 #-}
   rule3339 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3340 #-}
   rule3340 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3341 #-}
   rule3341 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3342 #-}
   rule3342 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3343 #-}
   rule3343 = \ _importEnvironment ->
     _importEnvironment
   {-# INLINE rule3344 #-}
   rule3344 = \ _matchIO ->
     _matchIO
   {-# INLINE rule3345 #-}
   rule3345 = \ _monos ->
     _monos
   {-# INLINE rule3346 #-}
   rule3346 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3347 #-}
   rule3347 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3348 #-}
   rule3348 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3349 #-}
   rule3349 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3350 #-}
   rule3350 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3351 #-}
   rule3351 = \ _tryPatterns ->
     _tryPatterns
   {-# INLINE rule3352 #-}
   rule3352 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3353 #-}
   rule3353 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3354 #-}
   rule3354 = \ _uniqueSecondRound ->
     _uniqueSecondRound

-- RecordExpressionBindings ------------------------------------
-- wrapper
data Inh_RecordExpressionBindings  = Inh_RecordExpressionBindings { allTypeSchemes_Inh_RecordExpressionBindings :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_RecordExpressionBindings :: (Predicates), classEnvironment_Inh_RecordExpressionBindings :: (ClassEnvironment), collectErrors_Inh_RecordExpressionBindings :: (TypeErrors), collectWarnings_Inh_RecordExpressionBindings :: (Warnings), counter_Inh_RecordExpressionBindings :: (Int), currentChunk_Inh_RecordExpressionBindings :: (Int), dictionaryEnvironment_Inh_RecordExpressionBindings :: (DictionaryEnvironment), importEnvironment_Inh_RecordExpressionBindings :: (ImportEnvironment), namesInScope_Inh_RecordExpressionBindings :: (Names), orderedTypeSynonyms_Inh_RecordExpressionBindings :: (OrderedTypeSynonyms), patternMatchWarnings_Inh_RecordExpressionBindings :: ([Warning]), substitution_Inh_RecordExpressionBindings :: (FixpointSubstitution), typeschemeMap_Inh_RecordExpressionBindings :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_RecordExpressionBindings :: (Int) }
data Syn_RecordExpressionBindings  = Syn_RecordExpressionBindings { collectErrors_Syn_RecordExpressionBindings :: (TypeErrors), collectInstances_Syn_RecordExpressionBindings :: ([(Name, Instance)]), collectWarnings_Syn_RecordExpressionBindings :: (Warnings), counter_Syn_RecordExpressionBindings :: (Int), dictionaryEnvironment_Syn_RecordExpressionBindings :: (DictionaryEnvironment), patternMatchWarnings_Syn_RecordExpressionBindings :: ([Warning]), self_Syn_RecordExpressionBindings :: (RecordExpressionBindings), unboundNames_Syn_RecordExpressionBindings :: (Names), uniqueChunk_Syn_RecordExpressionBindings :: (Int) }
{-# INLINABLE wrap_RecordExpressionBindings #-}
wrap_RecordExpressionBindings :: T_RecordExpressionBindings  -> Inh_RecordExpressionBindings  -> (Syn_RecordExpressionBindings )
wrap_RecordExpressionBindings (T_RecordExpressionBindings act) (Inh_RecordExpressionBindings _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_RecordExpressionBindings_vIn139 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_RecordExpressionBindings_vOut139 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_RecordExpressionBindings_s140 sem arg)
        return (Syn_RecordExpressionBindings _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_RecordExpressionBindings #-}
sem_RecordExpressionBindings :: RecordExpressionBindings  -> T_RecordExpressionBindings 
sem_RecordExpressionBindings list = Prelude.foldr sem_RecordExpressionBindings_Cons sem_RecordExpressionBindings_Nil (Prelude.map sem_RecordExpressionBinding list)

-- semantic domain
newtype T_RecordExpressionBindings  = T_RecordExpressionBindings {
                                                                 attach_T_RecordExpressionBindings :: Identity (T_RecordExpressionBindings_s140 )
                                                                 }
newtype T_RecordExpressionBindings_s140  = C_RecordExpressionBindings_s140 {
                                                                           inv_RecordExpressionBindings_s140 :: (T_RecordExpressionBindings_v139 )
                                                                           }
data T_RecordExpressionBindings_s141  = C_RecordExpressionBindings_s141
type T_RecordExpressionBindings_v139  = (T_RecordExpressionBindings_vIn139 ) -> (T_RecordExpressionBindings_vOut139 )
data T_RecordExpressionBindings_vIn139  = T_RecordExpressionBindings_vIn139 (M.Map NameWithRange TpScheme) (Predicates) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (Names) (OrderedTypeSynonyms) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_RecordExpressionBindings_vOut139  = T_RecordExpressionBindings_vOut139 (TypeErrors) ([(Name, Instance)]) (Warnings) (Int) (DictionaryEnvironment) ([Warning]) (RecordExpressionBindings) (Names) (Int)
{-# NOINLINE sem_RecordExpressionBindings_Cons #-}
sem_RecordExpressionBindings_Cons :: T_RecordExpressionBinding  -> T_RecordExpressionBindings  -> T_RecordExpressionBindings 
sem_RecordExpressionBindings_Cons arg_hd_ arg_tl_ = T_RecordExpressionBindings (return st140) where
   {-# NOINLINE st140 #-}
   st140 = let
      v139 :: T_RecordExpressionBindings_v139 
      v139 = \ (T_RecordExpressionBindings_vIn139 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _hdX137 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBinding (arg_hd_))
         _tlX140 = Control.Monad.Identity.runIdentity (attach_T_RecordExpressionBindings (arg_tl_))
         (T_RecordExpressionBinding_vOut136 _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIcounter _hdIdictionaryEnvironment _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk) = inv_RecordExpressionBinding_s137 _hdX137 (T_RecordExpressionBinding_vIn136 _hdOallTypeSchemes _hdOavailablePredicates _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOimportEnvironment _hdOnamesInScope _hdOorderedTypeSynonyms _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOuniqueChunk)
         (T_RecordExpressionBindings_vOut139 _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIcounter _tlIdictionaryEnvironment _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk) = inv_RecordExpressionBindings_s140 _tlX140 (T_RecordExpressionBindings_vIn139 _tlOallTypeSchemes _tlOavailablePredicates _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOimportEnvironment _tlOnamesInScope _tlOorderedTypeSynonyms _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOuniqueChunk)
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3355 _hdIcollectInstances _tlIcollectInstances
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3356 _hdIunboundNames _tlIunboundNames
         _self = rule3357 _hdIself _tlIself
         _lhsOself :: RecordExpressionBindings
         _lhsOself = rule3358 _self
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3359 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3360 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3361 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3362 _tlIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3363 _tlIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3364 _tlIuniqueChunk
         _hdOallTypeSchemes = rule3365 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule3366 _lhsIavailablePredicates
         _hdOclassEnvironment = rule3367 _lhsIclassEnvironment
         _hdOcollectErrors = rule3368 _lhsIcollectErrors
         _hdOcollectWarnings = rule3369 _lhsIcollectWarnings
         _hdOcounter = rule3370 _lhsIcounter
         _hdOcurrentChunk = rule3371 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule3372 _lhsIdictionaryEnvironment
         _hdOimportEnvironment = rule3373 _lhsIimportEnvironment
         _hdOnamesInScope = rule3374 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule3375 _lhsIorderedTypeSynonyms
         _hdOpatternMatchWarnings = rule3376 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule3377 _lhsIsubstitution
         _hdOtypeschemeMap = rule3378 _lhsItypeschemeMap
         _hdOuniqueChunk = rule3379 _lhsIuniqueChunk
         _tlOallTypeSchemes = rule3380 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule3381 _lhsIavailablePredicates
         _tlOclassEnvironment = rule3382 _lhsIclassEnvironment
         _tlOcollectErrors = rule3383 _hdIcollectErrors
         _tlOcollectWarnings = rule3384 _hdIcollectWarnings
         _tlOcounter = rule3385 _hdIcounter
         _tlOcurrentChunk = rule3386 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule3387 _hdIdictionaryEnvironment
         _tlOimportEnvironment = rule3388 _lhsIimportEnvironment
         _tlOnamesInScope = rule3389 _lhsInamesInScope
         _tlOorderedTypeSynonyms = rule3390 _lhsIorderedTypeSynonyms
         _tlOpatternMatchWarnings = rule3391 _hdIpatternMatchWarnings
         _tlOsubstitution = rule3392 _lhsIsubstitution
         _tlOtypeschemeMap = rule3393 _lhsItypeschemeMap
         _tlOuniqueChunk = rule3394 _hdIuniqueChunk
         __result_ = T_RecordExpressionBindings_vOut139 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_RecordExpressionBindings_s140 v139
   {-# INLINE rule3355 #-}
   rule3355 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule3356 #-}
   rule3356 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule3357 #-}
   rule3357 = \ ((_hdIself) :: RecordExpressionBinding) ((_tlIself) :: RecordExpressionBindings) ->
     (:) _hdIself _tlIself
   {-# INLINE rule3358 #-}
   rule3358 = \ _self ->
     _self
   {-# INLINE rule3359 #-}
   rule3359 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule3360 #-}
   rule3360 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule3361 #-}
   rule3361 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule3362 #-}
   rule3362 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule3363 #-}
   rule3363 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule3364 #-}
   rule3364 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule3365 #-}
   rule3365 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3366 #-}
   rule3366 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3367 #-}
   rule3367 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3368 #-}
   rule3368 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3369 #-}
   rule3369 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3370 #-}
   rule3370 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3371 #-}
   rule3371 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3372 #-}
   rule3372 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3373 #-}
   rule3373 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3374 #-}
   rule3374 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3375 #-}
   rule3375 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3376 #-}
   rule3376 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3377 #-}
   rule3377 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3378 #-}
   rule3378 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3379 #-}
   rule3379 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3380 #-}
   rule3380 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3381 #-}
   rule3381 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3382 #-}
   rule3382 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3383 #-}
   rule3383 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule3384 #-}
   rule3384 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule3385 #-}
   rule3385 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule3386 #-}
   rule3386 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3387 #-}
   rule3387 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule3388 #-}
   rule3388 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3389 #-}
   rule3389 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3390 #-}
   rule3390 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3391 #-}
   rule3391 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule3392 #-}
   rule3392 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3393 #-}
   rule3393 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3394 #-}
   rule3394 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
{-# NOINLINE sem_RecordExpressionBindings_Nil #-}
sem_RecordExpressionBindings_Nil ::  T_RecordExpressionBindings 
sem_RecordExpressionBindings_Nil  = T_RecordExpressionBindings (return st140) where
   {-# NOINLINE st140 #-}
   st140 = let
      v139 :: T_RecordExpressionBindings_v139 
      v139 = \ (T_RecordExpressionBindings_vIn139 _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3395  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3396  ()
         _self = rule3397  ()
         _lhsOself :: RecordExpressionBindings
         _lhsOself = rule3398 _self
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3399 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3400 _lhsIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3401 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3402 _lhsIdictionaryEnvironment
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3403 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3404 _lhsIuniqueChunk
         __result_ = T_RecordExpressionBindings_vOut139 _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOcounter _lhsOdictionaryEnvironment _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_RecordExpressionBindings_s140 v139
   {-# INLINE rule3395 #-}
   rule3395 = \  (_ :: ()) ->
     []
   {-# INLINE rule3396 #-}
   rule3396 = \  (_ :: ()) ->
     []
   {-# INLINE rule3397 #-}
   rule3397 = \  (_ :: ()) ->
     []
   {-# INLINE rule3398 #-}
   rule3398 = \ _self ->
     _self
   {-# INLINE rule3399 #-}
   rule3399 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3400 #-}
   rule3400 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3401 #-}
   rule3401 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3402 #-}
   rule3402 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3403 #-}
   rule3403 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3404 #-}
   rule3404 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk

-- RecordPatternBinding ----------------------------------------
-- wrapper
data Inh_RecordPatternBinding  = Inh_RecordPatternBinding { counter_Inh_RecordPatternBinding :: (Int), namesInScope_Inh_RecordPatternBinding :: (Names), patternMatchWarnings_Inh_RecordPatternBinding :: ([Warning]) }
data Syn_RecordPatternBinding  = Syn_RecordPatternBinding { counter_Syn_RecordPatternBinding :: (Int), patternMatchWarnings_Syn_RecordPatternBinding :: ([Warning]), self_Syn_RecordPatternBinding :: (RecordPatternBinding), unboundNames_Syn_RecordPatternBinding :: (Names) }
{-# INLINABLE wrap_RecordPatternBinding #-}
wrap_RecordPatternBinding :: T_RecordPatternBinding  -> Inh_RecordPatternBinding  -> (Syn_RecordPatternBinding )
wrap_RecordPatternBinding (T_RecordPatternBinding act) (Inh_RecordPatternBinding _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_RecordPatternBinding_vIn142 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings
        (T_RecordPatternBinding_vOut142 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_RecordPatternBinding_s143 sem arg)
        return (Syn_RecordPatternBinding _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_RecordPatternBinding #-}
sem_RecordPatternBinding :: RecordPatternBinding  -> T_RecordPatternBinding 
sem_RecordPatternBinding ( RecordPatternBinding_RecordPatternBinding range_ name_ pattern_ ) = sem_RecordPatternBinding_RecordPatternBinding ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Pattern pattern_ )

-- semantic domain
newtype T_RecordPatternBinding  = T_RecordPatternBinding {
                                                         attach_T_RecordPatternBinding :: Identity (T_RecordPatternBinding_s143 )
                                                         }
newtype T_RecordPatternBinding_s143  = C_RecordPatternBinding_s143 {
                                                                   inv_RecordPatternBinding_s143 :: (T_RecordPatternBinding_v142 )
                                                                   }
data T_RecordPatternBinding_s144  = C_RecordPatternBinding_s144
type T_RecordPatternBinding_v142  = (T_RecordPatternBinding_vIn142 ) -> (T_RecordPatternBinding_vOut142 )
data T_RecordPatternBinding_vIn142  = T_RecordPatternBinding_vIn142 (Int) (Names) ([Warning])
data T_RecordPatternBinding_vOut142  = T_RecordPatternBinding_vOut142 (Int) ([Warning]) (RecordPatternBinding) (Names)
{-# NOINLINE sem_RecordPatternBinding_RecordPatternBinding #-}
sem_RecordPatternBinding_RecordPatternBinding :: T_Range  -> T_Name  -> T_Pattern  -> T_RecordPatternBinding 
sem_RecordPatternBinding_RecordPatternBinding arg_range_ arg_name_ arg_pattern_ = T_RecordPatternBinding (return st143) where
   {-# NOINLINE st143 #-}
   st143 = let
      v142 :: T_RecordPatternBinding_v142 
      v142 = \ (T_RecordPatternBinding_vIn142 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         _parentTree = rule3405  ()
         (_monos,_constructorenv,_betaUnique,_miscerrors,_warnings,_valueConstructors,_allValueConstructors,_typeConstructors,_allTypeConstructors,_importEnvironment) = rule3406  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3407 _patternIunboundNames
         _self = rule3408 _nameIself _patternIself _rangeIself
         _lhsOself :: RecordPatternBinding
         _lhsOself = rule3409 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule3410 _patternIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3411 _patternIpatternMatchWarnings
         _patternObetaUnique = rule3412 _betaUnique
         _patternOcounter = rule3413 _lhsIcounter
         _patternOimportEnvironment = rule3414 _importEnvironment
         _patternOmonos = rule3415 _monos
         _patternOnamesInScope = rule3416 _lhsInamesInScope
         _patternOparentTree = rule3417 _parentTree
         _patternOpatternMatchWarnings = rule3418 _lhsIpatternMatchWarnings
         __result_ = T_RecordPatternBinding_vOut142 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_RecordPatternBinding_s143 v142
   {-# INLINE rule3405 #-}
   rule3405 = \  (_ :: ()) ->
                                                                            globalInfoError
   {-# INLINE rule3406 #-}
   rule3406 = \  (_ :: ()) ->
                                                                                                                                                                                          internalError "PartialSyntax.ag" "n/a" "RecordPatternBinding.RecordPatternBinding"
   {-# INLINE rule3407 #-}
   rule3407 = \ ((_patternIunboundNames) :: Names) ->
     _patternIunboundNames
   {-# INLINE rule3408 #-}
   rule3408 = \ ((_nameIself) :: Name) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
     RecordPatternBinding_RecordPatternBinding _rangeIself _nameIself _patternIself
   {-# INLINE rule3409 #-}
   rule3409 = \ _self ->
     _self
   {-# INLINE rule3410 #-}
   rule3410 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule3411 #-}
   rule3411 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule3412 #-}
   rule3412 = \ _betaUnique ->
     _betaUnique
   {-# INLINE rule3413 #-}
   rule3413 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3414 #-}
   rule3414 = \ _importEnvironment ->
     _importEnvironment
   {-# INLINE rule3415 #-}
   rule3415 = \ _monos ->
     _monos
   {-# INLINE rule3416 #-}
   rule3416 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3417 #-}
   rule3417 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3418 #-}
   rule3418 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings

-- RecordPatternBindings ---------------------------------------
-- wrapper
data Inh_RecordPatternBindings  = Inh_RecordPatternBindings { counter_Inh_RecordPatternBindings :: (Int), namesInScope_Inh_RecordPatternBindings :: (Names), patternMatchWarnings_Inh_RecordPatternBindings :: ([Warning]) }
data Syn_RecordPatternBindings  = Syn_RecordPatternBindings { counter_Syn_RecordPatternBindings :: (Int), patternMatchWarnings_Syn_RecordPatternBindings :: ([Warning]), self_Syn_RecordPatternBindings :: (RecordPatternBindings), unboundNames_Syn_RecordPatternBindings :: (Names) }
{-# INLINABLE wrap_RecordPatternBindings #-}
wrap_RecordPatternBindings :: T_RecordPatternBindings  -> Inh_RecordPatternBindings  -> (Syn_RecordPatternBindings )
wrap_RecordPatternBindings (T_RecordPatternBindings act) (Inh_RecordPatternBindings _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_RecordPatternBindings_vIn145 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings
        (T_RecordPatternBindings_vOut145 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames) <- return (inv_RecordPatternBindings_s146 sem arg)
        return (Syn_RecordPatternBindings _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames)
   )

-- cata
{-# NOINLINE sem_RecordPatternBindings #-}
sem_RecordPatternBindings :: RecordPatternBindings  -> T_RecordPatternBindings 
sem_RecordPatternBindings list = Prelude.foldr sem_RecordPatternBindings_Cons sem_RecordPatternBindings_Nil (Prelude.map sem_RecordPatternBinding list)

-- semantic domain
newtype T_RecordPatternBindings  = T_RecordPatternBindings {
                                                           attach_T_RecordPatternBindings :: Identity (T_RecordPatternBindings_s146 )
                                                           }
newtype T_RecordPatternBindings_s146  = C_RecordPatternBindings_s146 {
                                                                     inv_RecordPatternBindings_s146 :: (T_RecordPatternBindings_v145 )
                                                                     }
data T_RecordPatternBindings_s147  = C_RecordPatternBindings_s147
type T_RecordPatternBindings_v145  = (T_RecordPatternBindings_vIn145 ) -> (T_RecordPatternBindings_vOut145 )
data T_RecordPatternBindings_vIn145  = T_RecordPatternBindings_vIn145 (Int) (Names) ([Warning])
data T_RecordPatternBindings_vOut145  = T_RecordPatternBindings_vOut145 (Int) ([Warning]) (RecordPatternBindings) (Names)
{-# NOINLINE sem_RecordPatternBindings_Cons #-}
sem_RecordPatternBindings_Cons :: T_RecordPatternBinding  -> T_RecordPatternBindings  -> T_RecordPatternBindings 
sem_RecordPatternBindings_Cons arg_hd_ arg_tl_ = T_RecordPatternBindings (return st146) where
   {-# NOINLINE st146 #-}
   st146 = let
      v145 :: T_RecordPatternBindings_v145 
      v145 = \ (T_RecordPatternBindings_vIn145 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) -> ( let
         _hdX143 = Control.Monad.Identity.runIdentity (attach_T_RecordPatternBinding (arg_hd_))
         _tlX146 = Control.Monad.Identity.runIdentity (attach_T_RecordPatternBindings (arg_tl_))
         (T_RecordPatternBinding_vOut142 _hdIcounter _hdIpatternMatchWarnings _hdIself _hdIunboundNames) = inv_RecordPatternBinding_s143 _hdX143 (T_RecordPatternBinding_vIn142 _hdOcounter _hdOnamesInScope _hdOpatternMatchWarnings)
         (T_RecordPatternBindings_vOut145 _tlIcounter _tlIpatternMatchWarnings _tlIself _tlIunboundNames) = inv_RecordPatternBindings_s146 _tlX146 (T_RecordPatternBindings_vIn145 _tlOcounter _tlOnamesInScope _tlOpatternMatchWarnings)
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3419 _hdIunboundNames _tlIunboundNames
         _self = rule3420 _hdIself _tlIself
         _lhsOself :: RecordPatternBindings
         _lhsOself = rule3421 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule3422 _tlIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3423 _tlIpatternMatchWarnings
         _hdOcounter = rule3424 _lhsIcounter
         _hdOnamesInScope = rule3425 _lhsInamesInScope
         _hdOpatternMatchWarnings = rule3426 _lhsIpatternMatchWarnings
         _tlOcounter = rule3427 _hdIcounter
         _tlOnamesInScope = rule3428 _lhsInamesInScope
         _tlOpatternMatchWarnings = rule3429 _hdIpatternMatchWarnings
         __result_ = T_RecordPatternBindings_vOut145 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_RecordPatternBindings_s146 v145
   {-# INLINE rule3419 #-}
   rule3419 = \ ((_hdIunboundNames) :: Names) ((_tlIunboundNames) :: Names) ->
     _hdIunboundNames ++ _tlIunboundNames
   {-# INLINE rule3420 #-}
   rule3420 = \ ((_hdIself) :: RecordPatternBinding) ((_tlIself) :: RecordPatternBindings) ->
     (:) _hdIself _tlIself
   {-# INLINE rule3421 #-}
   rule3421 = \ _self ->
     _self
   {-# INLINE rule3422 #-}
   rule3422 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule3423 #-}
   rule3423 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule3424 #-}
   rule3424 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3425 #-}
   rule3425 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3426 #-}
   rule3426 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3427 #-}
   rule3427 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule3428 #-}
   rule3428 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3429 #-}
   rule3429 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
{-# NOINLINE sem_RecordPatternBindings_Nil #-}
sem_RecordPatternBindings_Nil ::  T_RecordPatternBindings 
sem_RecordPatternBindings_Nil  = T_RecordPatternBindings (return st146) where
   {-# NOINLINE st146 #-}
   st146 = let
      v145 :: T_RecordPatternBindings_v145 
      v145 = \ (T_RecordPatternBindings_vIn145 _lhsIcounter _lhsInamesInScope _lhsIpatternMatchWarnings) -> ( let
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3430  ()
         _self = rule3431  ()
         _lhsOself :: RecordPatternBindings
         _lhsOself = rule3432 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule3433 _lhsIcounter
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3434 _lhsIpatternMatchWarnings
         __result_ = T_RecordPatternBindings_vOut145 _lhsOcounter _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames
         in __result_ )
     in C_RecordPatternBindings_s146 v145
   {-# INLINE rule3430 #-}
   rule3430 = \  (_ :: ()) ->
     []
   {-# INLINE rule3431 #-}
   rule3431 = \  (_ :: ()) ->
     []
   {-# INLINE rule3432 #-}
   rule3432 = \ _self ->
     _self
   {-# INLINE rule3433 #-}
   rule3433 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3434 #-}
   rule3434 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings

-- RightHandSide -----------------------------------------------
-- wrapper
data Inh_RightHandSide  = Inh_RightHandSide { allPatterns_Inh_RightHandSide :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_RightHandSide :: (M.Map NameWithRange TpScheme), availablePredicates_Inh_RightHandSide :: (Predicates), betaRight_Inh_RightHandSide :: (Tp), betaUnique_Inh_RightHandSide :: (Int), classEnvironment_Inh_RightHandSide :: (ClassEnvironment), collectErrors_Inh_RightHandSide :: (TypeErrors), collectWarnings_Inh_RightHandSide :: (Warnings), counter_Inh_RightHandSide :: (Int), currentChunk_Inh_RightHandSide :: (Int), dictionaryEnvironment_Inh_RightHandSide :: (DictionaryEnvironment), importEnvironment_Inh_RightHandSide :: (ImportEnvironment), matchIO_Inh_RightHandSide :: (IO ()), monos_Inh_RightHandSide :: (Monos), namesInScope_Inh_RightHandSide :: (Names), orderedTypeSynonyms_Inh_RightHandSide :: (OrderedTypeSynonyms), parentTree_Inh_RightHandSide :: (InfoTree), patternMatchWarnings_Inh_RightHandSide :: ([Warning]), substitution_Inh_RightHandSide :: (FixpointSubstitution), typeschemeMap_Inh_RightHandSide :: (M.Map Int (Scheme Predicates)), uniqueChunk_Inh_RightHandSide :: (Int) }
data Syn_RightHandSide  = Syn_RightHandSide { assumptions_Syn_RightHandSide :: (Assumptions), betaUnique_Syn_RightHandSide :: (Int), collectErrors_Syn_RightHandSide :: (TypeErrors), collectInstances_Syn_RightHandSide :: ([(Name, Instance)]), collectWarnings_Syn_RightHandSide :: (Warnings), constraints_Syn_RightHandSide :: (ConstraintSet), counter_Syn_RightHandSide :: (Int), dictionaryEnvironment_Syn_RightHandSide :: (DictionaryEnvironment), fallthrough_Syn_RightHandSide :: (Bool), infoTree_Syn_RightHandSide :: (InfoTree), matchIO_Syn_RightHandSide :: (IO ()), patternMatchWarnings_Syn_RightHandSide :: ([Warning]), self_Syn_RightHandSide :: (RightHandSide), unboundNames_Syn_RightHandSide :: (Names), uniqueChunk_Syn_RightHandSide :: (Int) }
{-# INLINABLE wrap_RightHandSide #-}
wrap_RightHandSide :: T_RightHandSide  -> Inh_RightHandSide  -> (Syn_RightHandSide )
wrap_RightHandSide (T_RightHandSide act) (Inh_RightHandSide _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_RightHandSide_vIn148 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk
        (T_RightHandSide_vOut148 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk) <- return (inv_RightHandSide_s149 sem arg)
        return (Syn_RightHandSide _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk)
   )

-- cata
{-# NOINLINE sem_RightHandSide #-}
sem_RightHandSide :: RightHandSide  -> T_RightHandSide 
sem_RightHandSide ( RightHandSide_Expression range_ expression_ where_ ) = sem_RightHandSide_Expression ( sem_Range range_ ) ( sem_Expression expression_ ) ( sem_MaybeDeclarations where_ )
sem_RightHandSide ( RightHandSide_Guarded range_ guardedexpressions_ where_ ) = sem_RightHandSide_Guarded ( sem_Range range_ ) ( sem_GuardedExpressions guardedexpressions_ ) ( sem_MaybeDeclarations where_ )

-- semantic domain
newtype T_RightHandSide  = T_RightHandSide {
                                           attach_T_RightHandSide :: Identity (T_RightHandSide_s149 )
                                           }
newtype T_RightHandSide_s149  = C_RightHandSide_s149 {
                                                     inv_RightHandSide_s149 :: (T_RightHandSide_v148 )
                                                     }
data T_RightHandSide_s150  = C_RightHandSide_s150
type T_RightHandSide_v148  = (T_RightHandSide_vIn148 ) -> (T_RightHandSide_vOut148 )
data T_RightHandSide_vIn148  = T_RightHandSide_vIn148 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Predicates) (Tp) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (Int) (Int) (DictionaryEnvironment) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Int)
data T_RightHandSide_vOut148  = T_RightHandSide_vOut148 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Bool) (InfoTree) (IO ()) ([Warning]) (RightHandSide) (Names) (Int)
{-# NOINLINE sem_RightHandSide_Expression #-}
sem_RightHandSide_Expression :: T_Range  -> T_Expression  -> T_MaybeDeclarations  -> T_RightHandSide 
sem_RightHandSide_Expression arg_range_ arg_expression_ arg_where_ = T_RightHandSide (return st149) where
   {-# NOINLINE st149 #-}
   st149 = let
      v148 :: T_RightHandSide_v148 
      v148 = \ (T_RightHandSide_vIn148 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         _whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         (T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3435 _whereIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3436 _whereIconstraints
         _whereOassumptions = rule3437 _expressionIassumptions
         _whereOconstraints = rule3438 _expressionIconstraints _newcon
         _newcon = rule3439 _cinfo _expressionIbeta _lhsIbetaRight
         _allTypeSchemes = rule3440 _lhsIallTypeSchemes _whereIlocalTypes
         _cinfo = rule3441 _lhsIbetaRight _lhsIparentTree _parentTree
         _localInfo = rule3442 _lhsImonos _self
         _parentTree = rule3443 _expressionIinfoTree _lhsIparentTree _localInfo _whereIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3444 _parentTree
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3445 _whereIunboundNames
         _expressionOnamesInScope = rule3446 _whereInamesInScope
         _whereOunboundNames = rule3447 _expressionIunboundNames
         _expressionOuniqueSecondRound = rule3448 _expressionIbetaUnique
         _whereObetaUnique = rule3449 _expressionIuniqueSecondRound
         _expressionOtryPatterns = rule3450  ()
         _lhsOfallthrough :: Bool
         _lhsOfallthrough = rule3451  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3452 _expressionIcollectInstances _whereIcollectInstances
         _self = rule3453 _expressionIself _rangeIself _whereIself
         _lhsOself :: RightHandSide
         _lhsOself = rule3454 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3455 _whereIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3456 _whereIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3457 _whereIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3458 _whereIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3459 _whereIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3460 _whereImatchIO
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3461 _whereIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3462 _whereIuniqueChunk
         _expressionOallPatterns = rule3463 _lhsIallPatterns
         _expressionOallTypeSchemes = rule3464 _allTypeSchemes
         _expressionOavailablePredicates = rule3465 _lhsIavailablePredicates
         _expressionObetaUnique = rule3466 _lhsIbetaUnique
         _expressionOclassEnvironment = rule3467 _lhsIclassEnvironment
         _expressionOcollectErrors = rule3468 _lhsIcollectErrors
         _expressionOcollectWarnings = rule3469 _lhsIcollectWarnings
         _expressionOcounter = rule3470 _lhsIcounter
         _expressionOcurrentChunk = rule3471 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule3472 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule3473 _lhsIimportEnvironment
         _expressionOmatchIO = rule3474 _lhsImatchIO
         _expressionOmonos = rule3475 _lhsImonos
         _expressionOorderedTypeSynonyms = rule3476 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule3477 _parentTree
         _expressionOpatternMatchWarnings = rule3478 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule3479 _lhsIsubstitution
         _expressionOtypeschemeMap = rule3480 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule3481 _lhsIuniqueChunk
         _whereOallPatterns = rule3482 _lhsIallPatterns
         _whereOallTypeSchemes = rule3483 _allTypeSchemes
         _whereOavailablePredicates = rule3484 _lhsIavailablePredicates
         _whereOclassEnvironment = rule3485 _lhsIclassEnvironment
         _whereOcollectErrors = rule3486 _expressionIcollectErrors
         _whereOcollectWarnings = rule3487 _expressionIcollectWarnings
         _whereOcounter = rule3488 _expressionIcounter
         _whereOcurrentChunk = rule3489 _lhsIcurrentChunk
         _whereOdictionaryEnvironment = rule3490 _expressionIdictionaryEnvironment
         _whereOimportEnvironment = rule3491 _lhsIimportEnvironment
         _whereOmatchIO = rule3492 _expressionImatchIO
         _whereOmonos = rule3493 _lhsImonos
         _whereOnamesInScope = rule3494 _lhsInamesInScope
         _whereOorderedTypeSynonyms = rule3495 _lhsIorderedTypeSynonyms
         _whereOparentTree = rule3496 _parentTree
         _whereOpatternMatchWarnings = rule3497 _expressionIpatternMatchWarnings
         _whereOsubstitution = rule3498 _lhsIsubstitution
         _whereOtypeschemeMap = rule3499 _lhsItypeschemeMap
         _whereOuniqueChunk = rule3500 _expressionIuniqueChunk
         __result_ = T_RightHandSide_vOut148 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_RightHandSide_s149 v148
   {-# INLINE rule3435 #-}
   rule3435 = \ ((_whereIassumptions) :: Assumptions) ->
                             _whereIassumptions
   {-# INLINE rule3436 #-}
   rule3436 = \ ((_whereIconstraints) :: ConstraintSet) ->
                             _whereIconstraints
   {-# INLINE rule3437 #-}
   rule3437 = \ ((_expressionIassumptions) :: Assumptions) ->
                             _expressionIassumptions
   {-# INLINE rule3438 #-}
   rule3438 = \ ((_expressionIconstraints) :: ConstraintSet) _newcon ->
                             _newcon .>. _expressionIconstraints
   {-# INLINE rule3439 #-}
   rule3439 = \ _cinfo ((_expressionIbeta) :: Tp) ((_lhsIbetaRight) :: Tp) ->
                             [ (_expressionIbeta .==. _lhsIbetaRight) _cinfo ]
   {-# INLINE rule3440 #-}
   rule3440 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_whereIlocalTypes) :: M.Map NameWithRange TpScheme) ->
                                         _whereIlocalTypes `M.union` _lhsIallTypeSchemes
   {-# INLINE rule3441 #-}
   rule3441 = \ ((_lhsIbetaRight) :: Tp) ((_lhsIparentTree) :: InfoTree) _parentTree ->
     orphanConstraint 0 "right-hand side" _parentTree
        [ Unifier (head (ftv _lhsIbetaRight)) ("right-hand sides", attribute (skip_UHA_FB_RHS _lhsIparentTree), "right-hand side") ]
   {-# INLINE rule3442 #-}
   rule3442 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_RHS _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3443 #-}
   rule3443 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_whereIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo (_expressionIinfoTree : _whereIinfoTrees)
   {-# INLINE rule3444 #-}
   rule3444 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3445 #-}
   rule3445 = \ ((_whereIunboundNames) :: Names) ->
                                                       _whereIunboundNames
   {-# INLINE rule3446 #-}
   rule3446 = \ ((_whereInamesInScope) :: Names) ->
                                                       _whereInamesInScope
   {-# INLINE rule3447 #-}
   rule3447 = \ ((_expressionIunboundNames) :: Names) ->
                                                       _expressionIunboundNames
   {-# INLINE rule3448 #-}
   rule3448 = \ ((_expressionIbetaUnique) :: Int) ->
                                                _expressionIbetaUnique
   {-# INLINE rule3449 #-}
   rule3449 = \ ((_expressionIuniqueSecondRound) :: Int) ->
                                                _expressionIuniqueSecondRound
   {-# INLINE rule3450 #-}
   rule3450 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule3451 #-}
   rule3451 = \  (_ :: ()) ->
                                            False
   {-# INLINE rule3452 #-}
   rule3452 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ((_whereIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances  ++  _whereIcollectInstances
   {-# INLINE rule3453 #-}
   rule3453 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ((_whereIself) :: MaybeDeclarations) ->
     RightHandSide_Expression _rangeIself _expressionIself _whereIself
   {-# INLINE rule3454 #-}
   rule3454 = \ _self ->
     _self
   {-# INLINE rule3455 #-}
   rule3455 = \ ((_whereIbetaUnique) :: Int) ->
     _whereIbetaUnique
   {-# INLINE rule3456 #-}
   rule3456 = \ ((_whereIcollectErrors) :: TypeErrors) ->
     _whereIcollectErrors
   {-# INLINE rule3457 #-}
   rule3457 = \ ((_whereIcollectWarnings) :: Warnings) ->
     _whereIcollectWarnings
   {-# INLINE rule3458 #-}
   rule3458 = \ ((_whereIcounter) :: Int) ->
     _whereIcounter
   {-# INLINE rule3459 #-}
   rule3459 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _whereIdictionaryEnvironment
   {-# INLINE rule3460 #-}
   rule3460 = \ ((_whereImatchIO) :: IO ()) ->
     _whereImatchIO
   {-# INLINE rule3461 #-}
   rule3461 = \ ((_whereIpatternMatchWarnings) :: [Warning]) ->
     _whereIpatternMatchWarnings
   {-# INLINE rule3462 #-}
   rule3462 = \ ((_whereIuniqueChunk) :: Int) ->
     _whereIuniqueChunk
   {-# INLINE rule3463 #-}
   rule3463 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3464 #-}
   rule3464 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule3465 #-}
   rule3465 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3466 #-}
   rule3466 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3467 #-}
   rule3467 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3468 #-}
   rule3468 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3469 #-}
   rule3469 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3470 #-}
   rule3470 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3471 #-}
   rule3471 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3472 #-}
   rule3472 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3473 #-}
   rule3473 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3474 #-}
   rule3474 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3475 #-}
   rule3475 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3476 #-}
   rule3476 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3477 #-}
   rule3477 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3478 #-}
   rule3478 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3479 #-}
   rule3479 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3480 #-}
   rule3480 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3481 #-}
   rule3481 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3482 #-}
   rule3482 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3483 #-}
   rule3483 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule3484 #-}
   rule3484 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3485 #-}
   rule3485 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3486 #-}
   rule3486 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule3487 #-}
   rule3487 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule3488 #-}
   rule3488 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule3489 #-}
   rule3489 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3490 #-}
   rule3490 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule3491 #-}
   rule3491 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3492 #-}
   rule3492 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule3493 #-}
   rule3493 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3494 #-}
   rule3494 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3495 #-}
   rule3495 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3496 #-}
   rule3496 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3497 #-}
   rule3497 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule3498 #-}
   rule3498 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3499 #-}
   rule3499 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3500 #-}
   rule3500 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
{-# NOINLINE sem_RightHandSide_Guarded #-}
sem_RightHandSide_Guarded :: T_Range  -> T_GuardedExpressions  -> T_MaybeDeclarations  -> T_RightHandSide 
sem_RightHandSide_Guarded arg_range_ arg_guardedexpressions_ arg_where_ = T_RightHandSide (return st149) where
   {-# NOINLINE st149 #-}
   st149 = let
      v148 :: T_RightHandSide_v148 
      v148 = \ (T_RightHandSide_vIn148 _lhsIallPatterns _lhsIallTypeSchemes _lhsIavailablePredicates _lhsIbetaRight _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIuniqueChunk) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _guardedexpressionsX65 = Control.Monad.Identity.runIdentity (attach_T_GuardedExpressions (arg_guardedexpressions_))
         _whereX89 = Control.Monad.Identity.runIdentity (attach_T_MaybeDeclarations (arg_where_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_GuardedExpressions_vOut64 _guardedexpressionsIassumptions _guardedexpressionsIbetaUnique _guardedexpressionsIcollectErrors _guardedexpressionsIcollectInstances _guardedexpressionsIcollectWarnings _guardedexpressionsIconstraintslist _guardedexpressionsIcounter _guardedexpressionsIdictionaryEnvironment _guardedexpressionsIfallthrough _guardedexpressionsIinfoTrees _guardedexpressionsImatchIO _guardedexpressionsIpatternMatchWarnings _guardedexpressionsIself _guardedexpressionsIunboundNames _guardedexpressionsIuniqueChunk _guardedexpressionsIuniqueSecondRound) = inv_GuardedExpressions_s65 _guardedexpressionsX65 (T_GuardedExpressions_vIn64 _guardedexpressionsOallPatterns _guardedexpressionsOallTypeSchemes _guardedexpressionsOavailablePredicates _guardedexpressionsObetaRight _guardedexpressionsObetaUnique _guardedexpressionsOclassEnvironment _guardedexpressionsOcollectErrors _guardedexpressionsOcollectWarnings _guardedexpressionsOcounter _guardedexpressionsOcurrentChunk _guardedexpressionsOdictionaryEnvironment _guardedexpressionsOimportEnvironment _guardedexpressionsOmatchIO _guardedexpressionsOmonos _guardedexpressionsOnamesInScope _guardedexpressionsOnumberOfGuards _guardedexpressionsOopen _guardedexpressionsOorderedTypeSynonyms _guardedexpressionsOparentTree _guardedexpressionsOpatternMatchWarnings _guardedexpressionsOsubstitution _guardedexpressionsOtypeschemeMap _guardedexpressionsOuniqueChunk _guardedexpressionsOuniqueSecondRound)
         (T_MaybeDeclarations_vOut88 _whereIassumptions _whereIbetaUnique _whereIcollectErrors _whereIcollectInstances _whereIcollectWarnings _whereIconstraints _whereIcounter _whereIdictionaryEnvironment _whereIinfoTrees _whereIlocalTypes _whereImatchIO _whereInamesInScope _whereIpatternMatchWarnings _whereIself _whereIunboundNames _whereIuniqueChunk) = inv_MaybeDeclarations_s89 _whereX89 (T_MaybeDeclarations_vIn88 _whereOallPatterns _whereOallTypeSchemes _whereOassumptions _whereOavailablePredicates _whereObetaUnique _whereOclassEnvironment _whereOcollectErrors _whereOcollectWarnings _whereOconstraints _whereOcounter _whereOcurrentChunk _whereOdictionaryEnvironment _whereOimportEnvironment _whereOmatchIO _whereOmonos _whereOnamesInScope _whereOorderedTypeSynonyms _whereOparentTree _whereOpatternMatchWarnings _whereOsubstitution _whereOtypeschemeMap _whereOunboundNames _whereOuniqueChunk)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3501 _whereIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3502 _whereIconstraints
         _guardedexpressionsOnumberOfGuards = rule3503 _guardedexpressionsIconstraintslist
         _whereOassumptions = rule3504 _guardedexpressionsIassumptions
         _whereOconstraints = rule3505 _guardedexpressionsIconstraintslist
         _allTypeSchemes = rule3506 _lhsIallTypeSchemes _whereIlocalTypes
         _localInfo = rule3507 _lhsImonos _self
         _parentTree = rule3508 _guardedexpressionsIinfoTrees _lhsIparentTree _localInfo _whereIinfoTrees
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3509 _parentTree
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3510 _whereIunboundNames
         _guardedexpressionsOnamesInScope = rule3511 _whereInamesInScope
         _whereOunboundNames = rule3512 _guardedexpressionsIunboundNames
         _guardedexpressionsOuniqueSecondRound = rule3513 _guardedexpressionsIbetaUnique
         _whereObetaUnique = rule3514 _guardedexpressionsIuniqueSecondRound
         _lhsOfallthrough :: Bool
         _lhsOfallthrough = rule3515 _guardedexpressionsIfallthrough
         _guardedexpressionsOopen = rule3516  ()
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3517 _guardedexpressionsIfallthrough _rangeIself _whereIpatternMatchWarnings
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3518 _guardedexpressionsIcollectInstances _whereIcollectInstances
         _self = rule3519 _guardedexpressionsIself _rangeIself _whereIself
         _lhsOself :: RightHandSide
         _lhsOself = rule3520 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3521 _whereIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3522 _whereIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3523 _whereIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3524 _whereIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3525 _whereIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3526 _whereImatchIO
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3527 _whereIuniqueChunk
         _guardedexpressionsOallPatterns = rule3528 _lhsIallPatterns
         _guardedexpressionsOallTypeSchemes = rule3529 _allTypeSchemes
         _guardedexpressionsOavailablePredicates = rule3530 _lhsIavailablePredicates
         _guardedexpressionsObetaRight = rule3531 _lhsIbetaRight
         _guardedexpressionsObetaUnique = rule3532 _lhsIbetaUnique
         _guardedexpressionsOclassEnvironment = rule3533 _lhsIclassEnvironment
         _guardedexpressionsOcollectErrors = rule3534 _lhsIcollectErrors
         _guardedexpressionsOcollectWarnings = rule3535 _lhsIcollectWarnings
         _guardedexpressionsOcounter = rule3536 _lhsIcounter
         _guardedexpressionsOcurrentChunk = rule3537 _lhsIcurrentChunk
         _guardedexpressionsOdictionaryEnvironment = rule3538 _lhsIdictionaryEnvironment
         _guardedexpressionsOimportEnvironment = rule3539 _lhsIimportEnvironment
         _guardedexpressionsOmatchIO = rule3540 _lhsImatchIO
         _guardedexpressionsOmonos = rule3541 _lhsImonos
         _guardedexpressionsOorderedTypeSynonyms = rule3542 _lhsIorderedTypeSynonyms
         _guardedexpressionsOparentTree = rule3543 _parentTree
         _guardedexpressionsOpatternMatchWarnings = rule3544 _lhsIpatternMatchWarnings
         _guardedexpressionsOsubstitution = rule3545 _lhsIsubstitution
         _guardedexpressionsOtypeschemeMap = rule3546 _lhsItypeschemeMap
         _guardedexpressionsOuniqueChunk = rule3547 _lhsIuniqueChunk
         _whereOallPatterns = rule3548 _lhsIallPatterns
         _whereOallTypeSchemes = rule3549 _allTypeSchemes
         _whereOavailablePredicates = rule3550 _lhsIavailablePredicates
         _whereOclassEnvironment = rule3551 _lhsIclassEnvironment
         _whereOcollectErrors = rule3552 _guardedexpressionsIcollectErrors
         _whereOcollectWarnings = rule3553 _guardedexpressionsIcollectWarnings
         _whereOcounter = rule3554 _guardedexpressionsIcounter
         _whereOcurrentChunk = rule3555 _lhsIcurrentChunk
         _whereOdictionaryEnvironment = rule3556 _guardedexpressionsIdictionaryEnvironment
         _whereOimportEnvironment = rule3557 _lhsIimportEnvironment
         _whereOmatchIO = rule3558 _guardedexpressionsImatchIO
         _whereOmonos = rule3559 _lhsImonos
         _whereOnamesInScope = rule3560 _lhsInamesInScope
         _whereOorderedTypeSynonyms = rule3561 _lhsIorderedTypeSynonyms
         _whereOparentTree = rule3562 _parentTree
         _whereOpatternMatchWarnings = rule3563 _guardedexpressionsIpatternMatchWarnings
         _whereOsubstitution = rule3564 _lhsIsubstitution
         _whereOtypeschemeMap = rule3565 _lhsItypeschemeMap
         _whereOuniqueChunk = rule3566 _guardedexpressionsIuniqueChunk
         __result_ = T_RightHandSide_vOut148 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOfallthrough _lhsOinfoTree _lhsOmatchIO _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk
         in __result_ )
     in C_RightHandSide_s149 v148
   {-# INLINE rule3501 #-}
   rule3501 = \ ((_whereIassumptions) :: Assumptions) ->
                                             _whereIassumptions
   {-# INLINE rule3502 #-}
   rule3502 = \ ((_whereIconstraints) :: ConstraintSet) ->
                                             _whereIconstraints
   {-# INLINE rule3503 #-}
   rule3503 = \ ((_guardedexpressionsIconstraintslist) :: ConstraintSets) ->
                                             length _guardedexpressionsIconstraintslist
   {-# INLINE rule3504 #-}
   rule3504 = \ ((_guardedexpressionsIassumptions) :: Assumptions) ->
                                             _guardedexpressionsIassumptions
   {-# INLINE rule3505 #-}
   rule3505 = \ ((_guardedexpressionsIconstraintslist) :: ConstraintSets) ->
                                             Node _guardedexpressionsIconstraintslist
   {-# INLINE rule3506 #-}
   rule3506 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ((_whereIlocalTypes) :: M.Map NameWithRange TpScheme) ->
                                         _whereIlocalTypes `M.union` _lhsIallTypeSchemes
   {-# INLINE rule3507 #-}
   rule3507 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_RHS _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3508 #-}
   rule3508 = \ ((_guardedexpressionsIinfoTrees) :: InfoTrees) ((_lhsIparentTree) :: InfoTree) _localInfo ((_whereIinfoTrees) :: InfoTrees) ->
                            node _lhsIparentTree _localInfo (_guardedexpressionsIinfoTrees ++ _whereIinfoTrees)
   {-# INLINE rule3509 #-}
   rule3509 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3510 #-}
   rule3510 = \ ((_whereIunboundNames) :: Names) ->
                                                       _whereIunboundNames
   {-# INLINE rule3511 #-}
   rule3511 = \ ((_whereInamesInScope) :: Names) ->
                                                       _whereInamesInScope
   {-# INLINE rule3512 #-}
   rule3512 = \ ((_guardedexpressionsIunboundNames) :: Names) ->
                                                       _guardedexpressionsIunboundNames
   {-# INLINE rule3513 #-}
   rule3513 = \ ((_guardedexpressionsIbetaUnique) :: Int) ->
                                                _guardedexpressionsIbetaUnique
   {-# INLINE rule3514 #-}
   rule3514 = \ ((_guardedexpressionsIuniqueSecondRound) :: Int) ->
                                                _guardedexpressionsIuniqueSecondRound
   {-# INLINE rule3515 #-}
   rule3515 = \ ((_guardedexpressionsIfallthrough) :: Bool) ->
                                            _guardedexpressionsIfallthrough
   {-# INLINE rule3516 #-}
   rule3516 = \  (_ :: ()) ->
                                                    True
   {-# INLINE rule3517 #-}
   rule3517 = \ ((_guardedexpressionsIfallthrough) :: Bool) ((_rangeIself) :: Range) ((_whereIpatternMatchWarnings) :: [Warning]) ->
                                                     (if _guardedexpressionsIfallthrough then [FallThrough _rangeIself] else [])
                                                     ++ _whereIpatternMatchWarnings
   {-# INLINE rule3518 #-}
   rule3518 = \ ((_guardedexpressionsIcollectInstances) :: [(Name, Instance)]) ((_whereIcollectInstances) :: [(Name, Instance)]) ->
     _guardedexpressionsIcollectInstances  ++  _whereIcollectInstances
   {-# INLINE rule3519 #-}
   rule3519 = \ ((_guardedexpressionsIself) :: GuardedExpressions) ((_rangeIself) :: Range) ((_whereIself) :: MaybeDeclarations) ->
     RightHandSide_Guarded _rangeIself _guardedexpressionsIself _whereIself
   {-# INLINE rule3520 #-}
   rule3520 = \ _self ->
     _self
   {-# INLINE rule3521 #-}
   rule3521 = \ ((_whereIbetaUnique) :: Int) ->
     _whereIbetaUnique
   {-# INLINE rule3522 #-}
   rule3522 = \ ((_whereIcollectErrors) :: TypeErrors) ->
     _whereIcollectErrors
   {-# INLINE rule3523 #-}
   rule3523 = \ ((_whereIcollectWarnings) :: Warnings) ->
     _whereIcollectWarnings
   {-# INLINE rule3524 #-}
   rule3524 = \ ((_whereIcounter) :: Int) ->
     _whereIcounter
   {-# INLINE rule3525 #-}
   rule3525 = \ ((_whereIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _whereIdictionaryEnvironment
   {-# INLINE rule3526 #-}
   rule3526 = \ ((_whereImatchIO) :: IO ()) ->
     _whereImatchIO
   {-# INLINE rule3527 #-}
   rule3527 = \ ((_whereIuniqueChunk) :: Int) ->
     _whereIuniqueChunk
   {-# INLINE rule3528 #-}
   rule3528 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3529 #-}
   rule3529 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule3530 #-}
   rule3530 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3531 #-}
   rule3531 = \ ((_lhsIbetaRight) :: Tp) ->
     _lhsIbetaRight
   {-# INLINE rule3532 #-}
   rule3532 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3533 #-}
   rule3533 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3534 #-}
   rule3534 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3535 #-}
   rule3535 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3536 #-}
   rule3536 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3537 #-}
   rule3537 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3538 #-}
   rule3538 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3539 #-}
   rule3539 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3540 #-}
   rule3540 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3541 #-}
   rule3541 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3542 #-}
   rule3542 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3543 #-}
   rule3543 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3544 #-}
   rule3544 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3545 #-}
   rule3545 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3546 #-}
   rule3546 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3547 #-}
   rule3547 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3548 #-}
   rule3548 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3549 #-}
   rule3549 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule3550 #-}
   rule3550 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3551 #-}
   rule3551 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3552 #-}
   rule3552 = \ ((_guardedexpressionsIcollectErrors) :: TypeErrors) ->
     _guardedexpressionsIcollectErrors
   {-# INLINE rule3553 #-}
   rule3553 = \ ((_guardedexpressionsIcollectWarnings) :: Warnings) ->
     _guardedexpressionsIcollectWarnings
   {-# INLINE rule3554 #-}
   rule3554 = \ ((_guardedexpressionsIcounter) :: Int) ->
     _guardedexpressionsIcounter
   {-# INLINE rule3555 #-}
   rule3555 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3556 #-}
   rule3556 = \ ((_guardedexpressionsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _guardedexpressionsIdictionaryEnvironment
   {-# INLINE rule3557 #-}
   rule3557 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3558 #-}
   rule3558 = \ ((_guardedexpressionsImatchIO) :: IO ()) ->
     _guardedexpressionsImatchIO
   {-# INLINE rule3559 #-}
   rule3559 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3560 #-}
   rule3560 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3561 #-}
   rule3561 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3562 #-}
   rule3562 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3563 #-}
   rule3563 = \ ((_guardedexpressionsIpatternMatchWarnings) :: [Warning]) ->
     _guardedexpressionsIpatternMatchWarnings
   {-# INLINE rule3564 #-}
   rule3564 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3565 #-}
   rule3565 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3566 #-}
   rule3566 = \ ((_guardedexpressionsIuniqueChunk) :: Int) ->
     _guardedexpressionsIuniqueChunk

-- SimpleType --------------------------------------------------
-- wrapper
data Inh_SimpleType  = Inh_SimpleType {  }
data Syn_SimpleType  = Syn_SimpleType { name_Syn_SimpleType :: (Name), self_Syn_SimpleType :: (SimpleType), typevariables_Syn_SimpleType :: (Names) }
{-# INLINABLE wrap_SimpleType #-}
wrap_SimpleType :: T_SimpleType  -> Inh_SimpleType  -> (Syn_SimpleType )
wrap_SimpleType (T_SimpleType act) (Inh_SimpleType ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_SimpleType_vIn151 
        (T_SimpleType_vOut151 _lhsOname _lhsOself _lhsOtypevariables) <- return (inv_SimpleType_s152 sem arg)
        return (Syn_SimpleType _lhsOname _lhsOself _lhsOtypevariables)
   )

-- cata
{-# INLINE sem_SimpleType #-}
sem_SimpleType :: SimpleType  -> T_SimpleType 
sem_SimpleType ( SimpleType_SimpleType range_ name_ typevariables_ ) = sem_SimpleType_SimpleType ( sem_Range range_ ) ( sem_Name name_ ) ( sem_Names typevariables_ )

-- semantic domain
newtype T_SimpleType  = T_SimpleType {
                                     attach_T_SimpleType :: Identity (T_SimpleType_s152 )
                                     }
newtype T_SimpleType_s152  = C_SimpleType_s152 {
                                               inv_SimpleType_s152 :: (T_SimpleType_v151 )
                                               }
data T_SimpleType_s153  = C_SimpleType_s153
type T_SimpleType_v151  = (T_SimpleType_vIn151 ) -> (T_SimpleType_vOut151 )
data T_SimpleType_vIn151  = T_SimpleType_vIn151 
data T_SimpleType_vOut151  = T_SimpleType_vOut151 (Name) (SimpleType) (Names)
{-# NOINLINE sem_SimpleType_SimpleType #-}
sem_SimpleType_SimpleType :: T_Range  -> T_Name  -> T_Names  -> T_SimpleType 
sem_SimpleType_SimpleType arg_range_ arg_name_ arg_typevariables_ = T_SimpleType (return st152) where
   {-# NOINLINE st152 #-}
   st152 = let
      v151 :: T_SimpleType_v151 
      v151 = \ (T_SimpleType_vIn151 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         _typevariablesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_typevariables_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         (T_Names_vOut115 _typevariablesIself) = inv_Names_s116 _typevariablesX116 (T_Names_vIn115 )
         _lhsOname :: Name
         _lhsOname = rule3567 _nameIself
         _lhsOtypevariables :: Names
         _lhsOtypevariables = rule3568 _typevariablesIself
         _self = rule3569 _nameIself _rangeIself _typevariablesIself
         _lhsOself :: SimpleType
         _lhsOself = rule3570 _self
         __result_ = T_SimpleType_vOut151 _lhsOname _lhsOself _lhsOtypevariables
         in __result_ )
     in C_SimpleType_s152 v151
   {-# INLINE rule3567 #-}
   rule3567 = \ ((_nameIself) :: Name) ->
                                        _nameIself
   {-# INLINE rule3568 #-}
   rule3568 = \ ((_typevariablesIself) :: Names) ->
                                        _typevariablesIself
   {-# INLINE rule3569 #-}
   rule3569 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ((_typevariablesIself) :: Names) ->
     SimpleType_SimpleType _rangeIself _nameIself _typevariablesIself
   {-# INLINE rule3570 #-}
   rule3570 = \ _self ->
     _self

-- Statement ---------------------------------------------------
-- wrapper
data Inh_Statement  = Inh_Statement { allPatterns_Inh_Statement :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Statement :: (M.Map NameWithRange TpScheme), assumptions_Inh_Statement :: (Assumptions), availablePredicates_Inh_Statement :: (Predicates), betaUnique_Inh_Statement :: (Int), classEnvironment_Inh_Statement :: (ClassEnvironment), collectErrors_Inh_Statement :: (TypeErrors), collectWarnings_Inh_Statement :: (Warnings), constraints_Inh_Statement :: (ConstraintSet), counter_Inh_Statement :: (Int), currentChunk_Inh_Statement :: (Int), dictionaryEnvironment_Inh_Statement :: (DictionaryEnvironment), generatorBeta_Inh_Statement :: (Maybe Tp), importEnvironment_Inh_Statement :: (ImportEnvironment), matchIO_Inh_Statement :: (IO ()), monos_Inh_Statement :: (Monos), namesInScope_Inh_Statement :: (Names), orderedTypeSynonyms_Inh_Statement :: (OrderedTypeSynonyms), parentTree_Inh_Statement :: (InfoTree), patternMatchWarnings_Inh_Statement :: ([Warning]), substitution_Inh_Statement :: (FixpointSubstitution), typeschemeMap_Inh_Statement :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Statement :: (Names), uniqueChunk_Inh_Statement :: (Int), uniqueSecondRound_Inh_Statement :: (Int) }
data Syn_Statement  = Syn_Statement { assumptions_Syn_Statement :: (Assumptions), betaUnique_Syn_Statement :: (Int), collectErrors_Syn_Statement :: (TypeErrors), collectInstances_Syn_Statement :: ([(Name, Instance)]), collectWarnings_Syn_Statement :: (Warnings), constraints_Syn_Statement :: (ConstraintSet), counter_Syn_Statement :: (Int), dictionaryEnvironment_Syn_Statement :: (DictionaryEnvironment), generatorBeta_Syn_Statement :: (Maybe Tp), infoTree_Syn_Statement :: (InfoTree), matchIO_Syn_Statement :: (IO ()), monos_Syn_Statement :: (Monos), namesInScope_Syn_Statement :: (Names), patternMatchWarnings_Syn_Statement :: ([Warning]), self_Syn_Statement :: (Statement), unboundNames_Syn_Statement :: (Names), uniqueChunk_Syn_Statement :: (Int), uniqueSecondRound_Syn_Statement :: (Int) }
{-# INLINABLE wrap_Statement #-}
wrap_Statement :: T_Statement  -> Inh_Statement  -> (Syn_Statement )
wrap_Statement (T_Statement act) (Inh_Statement _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Statement_s155 sem arg)
        return (Syn_Statement _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_Statement #-}
sem_Statement :: Statement  -> T_Statement 
sem_Statement ( Statement_Expression range_ expression_ ) = sem_Statement_Expression ( sem_Range range_ ) ( sem_Expression expression_ )
sem_Statement ( Statement_Let range_ declarations_ ) = sem_Statement_Let ( sem_Range range_ ) ( sem_Declarations declarations_ )
sem_Statement ( Statement_Generator range_ pattern_ expression_ ) = sem_Statement_Generator ( sem_Range range_ ) ( sem_Pattern pattern_ ) ( sem_Expression expression_ )
sem_Statement ( Statement_Empty range_ ) = sem_Statement_Empty ( sem_Range range_ )

-- semantic domain
newtype T_Statement  = T_Statement {
                                   attach_T_Statement :: Identity (T_Statement_s155 )
                                   }
newtype T_Statement_s155  = C_Statement_s155 {
                                             inv_Statement_s155 :: (T_Statement_v154 )
                                             }
data T_Statement_s156  = C_Statement_s156
type T_Statement_v154  = (T_Statement_vIn154 ) -> (T_Statement_vOut154 )
data T_Statement_vIn154  = T_Statement_vIn154 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (Maybe Tp) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Statement_vOut154  = T_Statement_vOut154 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Maybe Tp) (InfoTree) (IO ()) (Monos) (Names) ([Warning]) (Statement) (Names) (Int) (Int)
{-# NOINLINE sem_Statement_Expression #-}
sem_Statement_Expression :: T_Range  -> T_Expression  -> T_Statement 
sem_Statement_Expression arg_range_ arg_expression_ = T_Statement (return st155) where
   {-# NOINLINE st155 #-}
   st155 = let
      v154 :: T_Statement_v154 
      v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOgeneratorBeta :: Maybe Tp
         _lhsOgeneratorBeta = rule3571 _beta
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3572 _expressionIassumptions _lhsIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3573 _locConstraints
         _expressionObetaUnique = rule3574 _lhsIbetaUnique
         _locConstraints = rule3575 _expressionIconstraints _lhsIconstraints _newcon
         _beta = rule3576 _lhsIbetaUnique
         _newcon = rule3577 _beta _cinfo _expressionIbeta
         _cinfo = rule3578 _parentTree
         _localInfo = rule3579 _lhsImonos _self
         _parentTree = rule3580 _expressionIinfoTree _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3581 _parentTree
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3582 _expressionIunboundNames _lhsIunboundNames
         _expressionOtryPatterns = rule3583  ()
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3584 _expressionIcollectInstances
         _self = rule3585 _expressionIself _rangeIself
         _lhsOself :: Statement
         _lhsOself = rule3586 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3587 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3588 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3589 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3590 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3591 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3592 _expressionImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3593 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3594 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3595 _expressionIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3596 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3597 _expressionIuniqueSecondRound
         _expressionOallPatterns = rule3598 _lhsIallPatterns
         _expressionOallTypeSchemes = rule3599 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule3600 _lhsIavailablePredicates
         _expressionOclassEnvironment = rule3601 _lhsIclassEnvironment
         _expressionOcollectErrors = rule3602 _lhsIcollectErrors
         _expressionOcollectWarnings = rule3603 _lhsIcollectWarnings
         _expressionOcounter = rule3604 _lhsIcounter
         _expressionOcurrentChunk = rule3605 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule3606 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule3607 _lhsIimportEnvironment
         _expressionOmatchIO = rule3608 _lhsImatchIO
         _expressionOmonos = rule3609 _lhsImonos
         _expressionOnamesInScope = rule3610 _lhsInamesInScope
         _expressionOorderedTypeSynonyms = rule3611 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule3612 _parentTree
         _expressionOpatternMatchWarnings = rule3613 _lhsIpatternMatchWarnings
         _expressionOsubstitution = rule3614 _lhsIsubstitution
         _expressionOtypeschemeMap = rule3615 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule3616 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule3617 _lhsIuniqueSecondRound
         __result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Statement_s155 v154
   {-# INLINE rule3571 #-}
   rule3571 = \ _beta ->
                                      Just _beta
   {-# INLINE rule3572 #-}
   rule3572 = \ ((_expressionIassumptions) :: Assumptions) ((_lhsIassumptions) :: Assumptions) ->
                                      _lhsIassumptions `combine` _expressionIassumptions
   {-# INLINE rule3573 #-}
   rule3573 = \ _locConstraints ->
                                      _locConstraints
   {-# INLINE rule3574 #-}
   rule3574 = \ ((_lhsIbetaUnique) :: Int) ->
                                      _lhsIbetaUnique + 1
   {-# INLINE rule3575 #-}
   rule3575 = \ ((_expressionIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ->
                                      Node [ _newcon .<. _expressionIconstraints
                                           , _lhsIconstraints
                                           ]
   {-# INLINE rule3576 #-}
   rule3576 = \ ((_lhsIbetaUnique) :: Int) ->
                                      TVar _lhsIbetaUnique
   {-# INLINE rule3577 #-}
   rule3577 = \ _beta _cinfo ((_expressionIbeta) :: Tp) ->
                                      [ (_expressionIbeta .==. ioType _beta) _cinfo ]
   {-# INLINE rule3578 #-}
   rule3578 = \ _parentTree ->
     orphanConstraint 0 "generator" _parentTree
        []
   {-# INLINE rule3579 #-}
   rule3579 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Stat _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3580 #-}
   rule3580 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_expressionIinfoTree]
   {-# INLINE rule3581 #-}
   rule3581 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3582 #-}
   rule3582 = \ ((_expressionIunboundNames) :: Names) ((_lhsIunboundNames) :: Names) ->
                                              _expressionIunboundNames ++ _lhsIunboundNames
   {-# INLINE rule3583 #-}
   rule3583 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule3584 #-}
   rule3584 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule3585 #-}
   rule3585 = \ ((_expressionIself) :: Expression) ((_rangeIself) :: Range) ->
     Statement_Expression _rangeIself _expressionIself
   {-# INLINE rule3586 #-}
   rule3586 = \ _self ->
     _self
   {-# INLINE rule3587 #-}
   rule3587 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule3588 #-}
   rule3588 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule3589 #-}
   rule3589 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule3590 #-}
   rule3590 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule3591 #-}
   rule3591 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule3592 #-}
   rule3592 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule3593 #-}
   rule3593 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3594 #-}
   rule3594 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3595 #-}
   rule3595 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ->
     _expressionIpatternMatchWarnings
   {-# INLINE rule3596 #-}
   rule3596 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule3597 #-}
   rule3597 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule3598 #-}
   rule3598 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3599 #-}
   rule3599 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3600 #-}
   rule3600 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3601 #-}
   rule3601 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3602 #-}
   rule3602 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3603 #-}
   rule3603 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3604 #-}
   rule3604 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3605 #-}
   rule3605 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3606 #-}
   rule3606 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3607 #-}
   rule3607 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3608 #-}
   rule3608 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3609 #-}
   rule3609 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3610 #-}
   rule3610 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3611 #-}
   rule3611 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3612 #-}
   rule3612 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3613 #-}
   rule3613 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3614 #-}
   rule3614 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3615 #-}
   rule3615 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3616 #-}
   rule3616 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3617 #-}
   rule3617 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Statement_Let #-}
sem_Statement_Let :: T_Range  -> T_Declarations  -> T_Statement 
sem_Statement_Let arg_range_ arg_declarations_ = T_Statement (return st155) where
   {-# NOINLINE st155 #-}
   st155 = let
      v154 :: T_Statement_v154 
      v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _declarationsX32 = Control.Monad.Identity.runIdentity (attach_T_Declarations (arg_declarations_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Declarations_vOut31 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsIcollectErrors _declarationsIcollectInstances _declarationsIcollectWarnings _declarationsIcounter _declarationsIdeclVarNames _declarationsIdictionaryEnvironment _declarationsIinfoTrees _declarationsImatchIO _declarationsIpatternMatchWarnings _declarationsIrestrictedNames _declarationsIself _declarationsIsimplePatNames _declarationsItypeSignatures _declarationsIunboundNames _declarationsIuniqueChunk) = inv_Declarations_s32 _declarationsX32 (T_Declarations_vIn31 _declarationsOallPatterns _declarationsOallTypeSchemes _declarationsOavailablePredicates _declarationsObetaUnique _declarationsObindingGroups _declarationsOclassEnvironment _declarationsOcollectErrors _declarationsOcollectWarnings _declarationsOcounter _declarationsOcurrentChunk _declarationsOdictionaryEnvironment _declarationsOimportEnvironment _declarationsOinheritedBDG _declarationsOmatchIO _declarationsOmonos _declarationsOnamesInScope _declarationsOorderedTypeSynonyms _declarationsOparentTree _declarationsOpatternMatchWarnings _declarationsOsubstitution _declarationsOtypeSignatures _declarationsOtypeschemeMap _declarationsOuniqueChunk)
         _lhsOgeneratorBeta :: Maybe Tp
         _lhsOgeneratorBeta = rule3618  ()
         _declarationsObindingGroups = rule3619  ()
         _lhsOassumptions :: Assumptions
         _lhsOconstraints :: ConstraintSet
         _lhsObetaUnique :: Int
         (_lhsOassumptions,_lhsOconstraints,_inheritedBDG,_chunkNr,_lhsObetaUnique,_implicitsFM) = rule3620 _declarationsIbetaUnique _declarationsIbindingGroups _declarationsItypeSignatures _declarationsIuniqueChunk _lhsIassumptions _lhsIconstraints _lhsIcurrentChunk _lhsImonos
         _inferredTypes = rule3621 _implicitsFM _lhsItypeschemeMap
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3622 _declarationsIcollectWarnings _declarationsIsimplePatNames _inferredTypes
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3623 _declarationsIcollectErrors _declarationsIrestrictedNames _inferredTypes
         _allTypeSchemes = rule3624 _lhsIallTypeSchemes _localTypes
         _localTypes = rule3625 _declarationsIbindingGroups _declarationsItypeSignatures _inferredTypes
         _declarationsOtypeSignatures = rule3626  ()
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3627 _chunkNr
         _localInfo = rule3628 _lhsImonos _self
         _declInfo = rule3629 _declarationsIself _lhsImonos
         _thisTree = rule3630 _declTree _lhsIparentTree _localInfo
         _declTree = rule3631 _declInfo _declarationsIinfoTrees _thisTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3632 _thisTree
         _declarationsOparentTree = rule3633 _declTree
         (_collectTypeConstructors,_collectValueConstructors,_collectTypeSynonyms,_collectConstructorEnv,_derivedFunctions,_operatorFixities) = rule3634  ()
         (_namesInScope,_unboundNames,_scopeInfo) = rule3635 _declarationsIdeclVarNames _declarationsIunboundNames _lhsInamesInScope _lhsIunboundNames
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3636 _unboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3637 _declarationsIcollectInstances
         _self = rule3638 _declarationsIself _rangeIself
         _lhsOself :: Statement
         _lhsOself = rule3639 _self
         _lhsOcounter :: Int
         _lhsOcounter = rule3640 _declarationsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3641 _declarationsIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3642 _declarationsImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3643 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3644 _namesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3645 _declarationsIpatternMatchWarnings
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3646 _lhsIuniqueSecondRound
         _declarationsOallPatterns = rule3647 _lhsIallPatterns
         _declarationsOallTypeSchemes = rule3648 _allTypeSchemes
         _declarationsOavailablePredicates = rule3649 _lhsIavailablePredicates
         _declarationsObetaUnique = rule3650 _lhsIbetaUnique
         _declarationsOclassEnvironment = rule3651 _lhsIclassEnvironment
         _declarationsOcollectErrors = rule3652 _lhsIcollectErrors
         _declarationsOcollectWarnings = rule3653 _lhsIcollectWarnings
         _declarationsOcounter = rule3654 _lhsIcounter
         _declarationsOcurrentChunk = rule3655 _lhsIcurrentChunk
         _declarationsOdictionaryEnvironment = rule3656 _lhsIdictionaryEnvironment
         _declarationsOimportEnvironment = rule3657 _lhsIimportEnvironment
         _declarationsOinheritedBDG = rule3658 _inheritedBDG
         _declarationsOmatchIO = rule3659 _lhsImatchIO
         _declarationsOmonos = rule3660 _lhsImonos
         _declarationsOnamesInScope = rule3661 _namesInScope
         _declarationsOorderedTypeSynonyms = rule3662 _lhsIorderedTypeSynonyms
         _declarationsOpatternMatchWarnings = rule3663 _lhsIpatternMatchWarnings
         _declarationsOsubstitution = rule3664 _lhsIsubstitution
         _declarationsOtypeschemeMap = rule3665 _lhsItypeschemeMap
         _declarationsOuniqueChunk = rule3666 _lhsIuniqueChunk
         __result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Statement_s155 v154
   {-# INLINE rule3618 #-}
   rule3618 = \  (_ :: ()) ->
                                        Nothing
   {-# INLINE rule3619 #-}
   rule3619 = \  (_ :: ()) ->
                                        []
   {-# INLINE rule3620 #-}
   rule3620 = \ ((_declarationsIbetaUnique) :: Int) ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) ((_declarationsIuniqueChunk) :: Int) ((_lhsIassumptions) :: Assumptions) ((_lhsIconstraints) :: ConstraintSet) ((_lhsIcurrentChunk) :: Int) ((_lhsImonos) :: Monos) ->
           let inputBDG    = (False, _lhsIcurrentChunk, _declarationsIuniqueChunk, _lhsImonos, _declarationsItypeSignatures, mybdggroup, _declarationsIbetaUnique)
               mybdggroup = Just (_lhsIassumptions, [_lhsIconstraints])
           in performBindingGroup inputBDG _declarationsIbindingGroups
   {-# INLINE rule3621 #-}
   rule3621 = \ _implicitsFM ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
                                        findInferredTypes _lhsItypeschemeMap _implicitsFM
   {-# INLINE rule3622 #-}
   rule3622 = \ ((_declarationsIcollectWarnings) :: Warnings) ((_declarationsIsimplePatNames) :: Names) _inferredTypes ->
                                        missingTypeSignature False _declarationsIsimplePatNames _inferredTypes
                                        ++ _declarationsIcollectWarnings
   {-# INLINE rule3623 #-}
   rule3623 = \ ((_declarationsIcollectErrors) :: TypeErrors) ((_declarationsIrestrictedNames) :: Names) _inferredTypes ->
                                        restrictedNameErrors _inferredTypes _declarationsIrestrictedNames
                                        ++ _declarationsIcollectErrors
   {-# INLINE rule3624 #-}
   rule3624 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) _localTypes ->
                                    _localTypes `M.union` _lhsIallTypeSchemes
   {-# INLINE rule3625 #-}
   rule3625 = \ ((_declarationsIbindingGroups) :: BindingGroups) ((_declarationsItypeSignatures) :: TypeEnvironment) _inferredTypes ->
                                    makeLocalTypeEnv (_declarationsItypeSignatures `M.union` _inferredTypes) _declarationsIbindingGroups
   {-# INLINE rule3626 #-}
   rule3626 = \  (_ :: ()) ->
                                                                  M.empty
   {-# INLINE rule3627 #-}
   rule3627 = \ _chunkNr ->
                                                     _chunkNr
   {-# INLINE rule3628 #-}
   rule3628 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Stat _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3629 #-}
   rule3629 = \ ((_declarationsIself) :: Declarations) ((_lhsImonos) :: Monos) ->
                          LocalInfo { self = UHA_Decls _declarationsIself
                                    , assignedType = Nothing
                                    , monos = _lhsImonos
                                    }
   {-# INLINE rule3630 #-}
   rule3630 = \ _declTree ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo [_declTree]
   {-# INLINE rule3631 #-}
   rule3631 = \ _declInfo ((_declarationsIinfoTrees) :: InfoTrees) _thisTree ->
                            node _thisTree _declInfo _declarationsIinfoTrees
   {-# INLINE rule3632 #-}
   rule3632 = \ _thisTree ->
                            _thisTree
   {-# INLINE rule3633 #-}
   rule3633 = \ _declTree ->
                                     _declTree
   {-# INLINE rule3634 #-}
   rule3634 = \  (_ :: ()) ->
                                                                                                                                                   internalError "PartialSyntax.ag" "n/a" "toplevel Statement"
   {-# INLINE rule3635 #-}
   rule3635 = \ ((_declarationsIdeclVarNames) :: Names) ((_declarationsIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ->
                                                             changeOfScope _declarationsIdeclVarNames (_declarationsIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
   {-# INLINE rule3636 #-}
   rule3636 = \ _unboundNames ->
                                              _unboundNames
   {-# INLINE rule3637 #-}
   rule3637 = \ ((_declarationsIcollectInstances) :: [(Name, Instance)]) ->
     _declarationsIcollectInstances
   {-# INLINE rule3638 #-}
   rule3638 = \ ((_declarationsIself) :: Declarations) ((_rangeIself) :: Range) ->
     Statement_Let _rangeIself _declarationsIself
   {-# INLINE rule3639 #-}
   rule3639 = \ _self ->
     _self
   {-# INLINE rule3640 #-}
   rule3640 = \ ((_declarationsIcounter) :: Int) ->
     _declarationsIcounter
   {-# INLINE rule3641 #-}
   rule3641 = \ ((_declarationsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _declarationsIdictionaryEnvironment
   {-# INLINE rule3642 #-}
   rule3642 = \ ((_declarationsImatchIO) :: IO ()) ->
     _declarationsImatchIO
   {-# INLINE rule3643 #-}
   rule3643 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3644 #-}
   rule3644 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule3645 #-}
   rule3645 = \ ((_declarationsIpatternMatchWarnings) :: [Warning]) ->
     _declarationsIpatternMatchWarnings
   {-# INLINE rule3646 #-}
   rule3646 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule3647 #-}
   rule3647 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3648 #-}
   rule3648 = \ _allTypeSchemes ->
     _allTypeSchemes
   {-# INLINE rule3649 #-}
   rule3649 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3650 #-}
   rule3650 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3651 #-}
   rule3651 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3652 #-}
   rule3652 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3653 #-}
   rule3653 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3654 #-}
   rule3654 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3655 #-}
   rule3655 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3656 #-}
   rule3656 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3657 #-}
   rule3657 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3658 #-}
   rule3658 = \ _inheritedBDG ->
     _inheritedBDG
   {-# INLINE rule3659 #-}
   rule3659 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3660 #-}
   rule3660 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3661 #-}
   rule3661 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule3662 #-}
   rule3662 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3663 #-}
   rule3663 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3664 #-}
   rule3664 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3665 #-}
   rule3665 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3666 #-}
   rule3666 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
{-# NOINLINE sem_Statement_Generator #-}
sem_Statement_Generator :: T_Range  -> T_Pattern  -> T_Expression  -> T_Statement 
sem_Statement_Generator arg_range_ arg_pattern_ arg_expression_ = T_Statement (return st155) where
   {-# NOINLINE st155 #-}
   st155 = let
      v154 :: T_Statement_v154 
      v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _patternX119 = Control.Monad.Identity.runIdentity (attach_T_Pattern (arg_pattern_))
         _expressionX41 = Control.Monad.Identity.runIdentity (attach_T_Expression (arg_expression_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Pattern_vOut118 _patternIbeta _patternIbetaUnique _patternIconstraints _patternIcounter _patternIelements _patternIenvironment _patternIinfoTree _patternIpatVarNames _patternIpatternMatchWarnings _patternIself _patternIunboundNames) = inv_Pattern_s119 _patternX119 (T_Pattern_vIn118 _patternObetaUnique _patternOcounter _patternOimportEnvironment _patternOmonos _patternOnamesInScope _patternOparentTree _patternOpatternMatchWarnings)
         (T_Expression_vOut40 _expressionIassumptions _expressionIbeta _expressionIbetaUnique _expressionIcollectErrors _expressionIcollectInstances _expressionIcollectWarnings _expressionIconstraints _expressionIcounter _expressionIdictionaryEnvironment _expressionIinfoTree _expressionImatchIO _expressionImatches _expressionIpatternMatchWarnings _expressionIself _expressionIunboundNames _expressionIuniqueChunk _expressionIuniqueSecondRound) = inv_Expression_s41 _expressionX41 (T_Expression_vIn40 _expressionOallPatterns _expressionOallTypeSchemes _expressionOavailablePredicates _expressionObetaUnique _expressionOclassEnvironment _expressionOcollectErrors _expressionOcollectWarnings _expressionOcounter _expressionOcurrentChunk _expressionOdictionaryEnvironment _expressionOimportEnvironment _expressionOmatchIO _expressionOmonos _expressionOnamesInScope _expressionOorderedTypeSynonyms _expressionOparentTree _expressionOpatternMatchWarnings _expressionOsubstitution _expressionOtryPatterns _expressionOtypeschemeMap _expressionOuniqueChunk _expressionOuniqueSecondRound)
         _lhsOgeneratorBeta :: Maybe Tp
         _lhsOgeneratorBeta = rule3667  ()
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3668 _locConstraints
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3669 _assumptions' _expressionIassumptions
         _lhsOmonos :: Monos
         _lhsOmonos = rule3670 _csetBinds _lhsImonos _patternIenvironment
         _locConstraints = rule3671 _csetBinds _expressionIconstraints _lhsIconstraints _newcon _patternIconstraints
         _newcon = rule3672 _cinfoResult _expressionIbeta _patternIbeta
         (_csetBinds,_assumptions') = rule3673 _cinfoBind _lhsIassumptions _patternIenvironment
         _cinfoResult = rule3674 _parentTree
         _cinfoBind = rule3675 _parentTree _patternIenvironment
         _localInfo = rule3676 _lhsImonos _self
         _parentTree = rule3677 _expressionIinfoTree _lhsIparentTree _localInfo _patternIinfoTree
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3678 _parentTree
         (_namesInScope,_unboundNames,_scopeInfo) = rule3679 _expressionIunboundNames _lhsInamesInScope _lhsIunboundNames _patternIpatVarNames
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3680 _namesInScope
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3681 _unboundNames
         _expressionOnamesInScope = rule3682 _lhsInamesInScope
         _expressionOtryPatterns = rule3683  ()
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3684 _expressionIpatternMatchWarnings _lhsIimportEnvironment _lhsIsubstitution _patternIbeta _patternIelements _rangeIself
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3685 _expressionIcollectInstances
         _self = rule3686 _expressionIself _patternIself _rangeIself
         _lhsOself :: Statement
         _lhsOself = rule3687 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3688 _expressionIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3689 _expressionIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3690 _expressionIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3691 _expressionIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3692 _expressionIdictionaryEnvironment
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3693 _expressionImatchIO
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3694 _expressionIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3695 _expressionIuniqueSecondRound
         _patternObetaUnique = rule3696 _lhsIbetaUnique
         _patternOcounter = rule3697 _lhsIcounter
         _patternOimportEnvironment = rule3698 _lhsIimportEnvironment
         _patternOmonos = rule3699 _lhsImonos
         _patternOnamesInScope = rule3700 _namesInScope
         _patternOparentTree = rule3701 _parentTree
         _patternOpatternMatchWarnings = rule3702 _lhsIpatternMatchWarnings
         _expressionOallPatterns = rule3703 _lhsIallPatterns
         _expressionOallTypeSchemes = rule3704 _lhsIallTypeSchemes
         _expressionOavailablePredicates = rule3705 _lhsIavailablePredicates
         _expressionObetaUnique = rule3706 _patternIbetaUnique
         _expressionOclassEnvironment = rule3707 _lhsIclassEnvironment
         _expressionOcollectErrors = rule3708 _lhsIcollectErrors
         _expressionOcollectWarnings = rule3709 _lhsIcollectWarnings
         _expressionOcounter = rule3710 _patternIcounter
         _expressionOcurrentChunk = rule3711 _lhsIcurrentChunk
         _expressionOdictionaryEnvironment = rule3712 _lhsIdictionaryEnvironment
         _expressionOimportEnvironment = rule3713 _lhsIimportEnvironment
         _expressionOmatchIO = rule3714 _lhsImatchIO
         _expressionOmonos = rule3715 _lhsImonos
         _expressionOorderedTypeSynonyms = rule3716 _lhsIorderedTypeSynonyms
         _expressionOparentTree = rule3717 _parentTree
         _expressionOpatternMatchWarnings = rule3718 _patternIpatternMatchWarnings
         _expressionOsubstitution = rule3719 _lhsIsubstitution
         _expressionOtypeschemeMap = rule3720 _lhsItypeschemeMap
         _expressionOuniqueChunk = rule3721 _lhsIuniqueChunk
         _expressionOuniqueSecondRound = rule3722 _lhsIuniqueSecondRound
         __result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Statement_s155 v154
   {-# INLINE rule3667 #-}
   rule3667 = \  (_ :: ()) ->
                              Nothing
   {-# INLINE rule3668 #-}
   rule3668 = \ _locConstraints ->
                              _locConstraints
   {-# INLINE rule3669 #-}
   rule3669 = \ _assumptions' ((_expressionIassumptions) :: Assumptions) ->
                              _assumptions' `combine` _expressionIassumptions
   {-# INLINE rule3670 #-}
   rule3670 = \ _csetBinds ((_lhsImonos) :: Monos) ((_patternIenvironment) :: PatternAssumptions) ->
                              M.elems _patternIenvironment ++ getMonos _csetBinds ++ _lhsImonos
   {-# INLINE rule3671 #-}
   rule3671 = \ _csetBinds ((_expressionIconstraints) :: ConstraintSet) ((_lhsIconstraints) :: ConstraintSet) _newcon ((_patternIconstraints) :: ConstraintSet) ->
                               _newcon .>. _csetBinds .>>.
                                  Node [ _patternIconstraints
                                       , _expressionIconstraints
                                       , _lhsIconstraints
                                       ]
   {-# INLINE rule3672 #-}
   rule3672 = \ _cinfoResult ((_expressionIbeta) :: Tp) ((_patternIbeta) :: Tp) ->
                              [ (_expressionIbeta .==. ioType _patternIbeta) _cinfoResult ]
   {-# INLINE rule3673 #-}
   rule3673 = \ _cinfoBind ((_lhsIassumptions) :: Assumptions) ((_patternIenvironment) :: PatternAssumptions) ->
                                         (_patternIenvironment .===. _lhsIassumptions) _cinfoBind
   {-# INLINE rule3674 #-}
   rule3674 = \ _parentTree ->
     childConstraint 1 "generator" _parentTree
        []
   {-# INLINE rule3675 #-}
   rule3675 = \ _parentTree ((_patternIenvironment) :: PatternAssumptions) ->
     \name -> variableConstraint "variable" (nameToUHA_Expr name)
        [ FolkloreConstraint
        , makeUnifier name "generator" _patternIenvironment _parentTree
        ]
   {-# INLINE rule3676 #-}
   rule3676 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Stat _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3677 #-}
   rule3677 = \ ((_expressionIinfoTree) :: InfoTree) ((_lhsIparentTree) :: InfoTree) _localInfo ((_patternIinfoTree) :: InfoTree) ->
                            node _lhsIparentTree _localInfo [_patternIinfoTree, _expressionIinfoTree]
   {-# INLINE rule3678 #-}
   rule3678 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3679 #-}
   rule3679 = \ ((_expressionIunboundNames) :: Names) ((_lhsInamesInScope) :: Names) ((_lhsIunboundNames) :: Names) ((_patternIpatVarNames) :: Names) ->
                                                                        changeOfScope _patternIpatVarNames (_expressionIunboundNames ++ _lhsIunboundNames) _lhsInamesInScope
   {-# INLINE rule3680 #-}
   rule3680 = \ _namesInScope ->
                                              _namesInScope
   {-# INLINE rule3681 #-}
   rule3681 = \ _unboundNames ->
                                              _unboundNames
   {-# INLINE rule3682 #-}
   rule3682 = \ ((_lhsInamesInScope) :: Names) ->
                                              _lhsInamesInScope
   {-# INLINE rule3683 #-}
   rule3683 = \  (_ :: ()) ->
                                                     []
   {-# INLINE rule3684 #-}
   rule3684 = \ ((_expressionIpatternMatchWarnings) :: [Warning]) ((_lhsIimportEnvironment) :: ImportEnvironment) ((_lhsIsubstitution) :: FixpointSubstitution) ((_patternIbeta) :: Tp) ((_patternIelements) ::   [PatternElement]        ) ((_rangeIself) :: Range) ->
                                                    patternMatchWarnings _lhsIimportEnvironment
                                                                         _lhsIsubstitution
                                                                         _patternIbeta
                                                                         (:[])
                                                                         [(_patternIelements, False)]
                                                                         _rangeIself
                                                                         Nothing
                                                                         False
                                                                         []
                                                                         "generator"
                                                                         "<-"
                                                    ++ _expressionIpatternMatchWarnings
   {-# INLINE rule3685 #-}
   rule3685 = \ ((_expressionIcollectInstances) :: [(Name, Instance)]) ->
     _expressionIcollectInstances
   {-# INLINE rule3686 #-}
   rule3686 = \ ((_expressionIself) :: Expression) ((_patternIself) :: Pattern) ((_rangeIself) :: Range) ->
     Statement_Generator _rangeIself _patternIself _expressionIself
   {-# INLINE rule3687 #-}
   rule3687 = \ _self ->
     _self
   {-# INLINE rule3688 #-}
   rule3688 = \ ((_expressionIbetaUnique) :: Int) ->
     _expressionIbetaUnique
   {-# INLINE rule3689 #-}
   rule3689 = \ ((_expressionIcollectErrors) :: TypeErrors) ->
     _expressionIcollectErrors
   {-# INLINE rule3690 #-}
   rule3690 = \ ((_expressionIcollectWarnings) :: Warnings) ->
     _expressionIcollectWarnings
   {-# INLINE rule3691 #-}
   rule3691 = \ ((_expressionIcounter) :: Int) ->
     _expressionIcounter
   {-# INLINE rule3692 #-}
   rule3692 = \ ((_expressionIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _expressionIdictionaryEnvironment
   {-# INLINE rule3693 #-}
   rule3693 = \ ((_expressionImatchIO) :: IO ()) ->
     _expressionImatchIO
   {-# INLINE rule3694 #-}
   rule3694 = \ ((_expressionIuniqueChunk) :: Int) ->
     _expressionIuniqueChunk
   {-# INLINE rule3695 #-}
   rule3695 = \ ((_expressionIuniqueSecondRound) :: Int) ->
     _expressionIuniqueSecondRound
   {-# INLINE rule3696 #-}
   rule3696 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3697 #-}
   rule3697 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3698 #-}
   rule3698 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3699 #-}
   rule3699 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3700 #-}
   rule3700 = \ _namesInScope ->
     _namesInScope
   {-# INLINE rule3701 #-}
   rule3701 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3702 #-}
   rule3702 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3703 #-}
   rule3703 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3704 #-}
   rule3704 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3705 #-}
   rule3705 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3706 #-}
   rule3706 = \ ((_patternIbetaUnique) :: Int) ->
     _patternIbetaUnique
   {-# INLINE rule3707 #-}
   rule3707 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3708 #-}
   rule3708 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3709 #-}
   rule3709 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3710 #-}
   rule3710 = \ ((_patternIcounter) :: Int) ->
     _patternIcounter
   {-# INLINE rule3711 #-}
   rule3711 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3712 #-}
   rule3712 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3713 #-}
   rule3713 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3714 #-}
   rule3714 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3715 #-}
   rule3715 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3716 #-}
   rule3716 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3717 #-}
   rule3717 = \ _parentTree ->
     _parentTree
   {-# INLINE rule3718 #-}
   rule3718 = \ ((_patternIpatternMatchWarnings) :: [Warning]) ->
     _patternIpatternMatchWarnings
   {-# INLINE rule3719 #-}
   rule3719 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3720 #-}
   rule3720 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3721 #-}
   rule3721 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3722 #-}
   rule3722 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
{-# NOINLINE sem_Statement_Empty #-}
sem_Statement_Empty :: T_Range  -> T_Statement 
sem_Statement_Empty arg_range_ = T_Statement (return st155) where
   {-# NOINLINE st155 #-}
   st155 = let
      v154 :: T_Statement_v154 
      v154 = \ (T_Statement_vIn154 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         _localInfo = rule3723 _lhsImonos _self
         _parentTree = rule3724 _lhsIparentTree _localInfo
         _lhsOinfoTree :: InfoTree
         _lhsOinfoTree = rule3725 _parentTree
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3726  ()
         _self = rule3727 _rangeIself
         _lhsOself :: Statement
         _lhsOself = rule3728 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3729 _lhsIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3730 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3731 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3732 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3733 _lhsIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule3734 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3735 _lhsIdictionaryEnvironment
         _lhsOgeneratorBeta :: Maybe Tp
         _lhsOgeneratorBeta = rule3736 _lhsIgeneratorBeta
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3737 _lhsImatchIO
         _lhsOmonos :: Monos
         _lhsOmonos = rule3738 _lhsImonos
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3739 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3740 _lhsIpatternMatchWarnings
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3741 _lhsIunboundNames
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3742 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3743 _lhsIuniqueSecondRound
         __result_ = T_Statement_vOut154 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTree _lhsOmatchIO _lhsOmonos _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Statement_s155 v154
   {-# INLINE rule3723 #-}
   rule3723 = \ ((_lhsImonos) :: Monos) _self ->
                            LocalInfo { self = UHA_Stat _self
                                      , assignedType = Nothing
                                      , monos = _lhsImonos
                                      }
   {-# INLINE rule3724 #-}
   rule3724 = \ ((_lhsIparentTree) :: InfoTree) _localInfo ->
                            node _lhsIparentTree _localInfo []
   {-# INLINE rule3725 #-}
   rule3725 = \ _parentTree ->
                            _parentTree
   {-# INLINE rule3726 #-}
   rule3726 = \  (_ :: ()) ->
     []
   {-# INLINE rule3727 #-}
   rule3727 = \ ((_rangeIself) :: Range) ->
     Statement_Empty _rangeIself
   {-# INLINE rule3728 #-}
   rule3728 = \ _self ->
     _self
   {-# INLINE rule3729 #-}
   rule3729 = \ ((_lhsIassumptions) :: Assumptions) ->
     _lhsIassumptions
   {-# INLINE rule3730 #-}
   rule3730 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3731 #-}
   rule3731 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3732 #-}
   rule3732 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3733 #-}
   rule3733 = \ ((_lhsIconstraints) :: ConstraintSet) ->
     _lhsIconstraints
   {-# INLINE rule3734 #-}
   rule3734 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3735 #-}
   rule3735 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3736 #-}
   rule3736 = \ ((_lhsIgeneratorBeta) :: Maybe Tp) ->
     _lhsIgeneratorBeta
   {-# INLINE rule3737 #-}
   rule3737 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3738 #-}
   rule3738 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3739 #-}
   rule3739 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3740 #-}
   rule3740 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3741 #-}
   rule3741 = \ ((_lhsIunboundNames) :: Names) ->
     _lhsIunboundNames
   {-# INLINE rule3742 #-}
   rule3742 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3743 #-}
   rule3743 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- Statements --------------------------------------------------
-- wrapper
data Inh_Statements  = Inh_Statements { allPatterns_Inh_Statements :: ([((Expression, [String]), Core_TypingStrategy)]), allTypeSchemes_Inh_Statements :: (M.Map NameWithRange TpScheme), assumptions_Inh_Statements :: (Assumptions), availablePredicates_Inh_Statements :: (Predicates), betaUnique_Inh_Statements :: (Int), classEnvironment_Inh_Statements :: (ClassEnvironment), collectErrors_Inh_Statements :: (TypeErrors), collectWarnings_Inh_Statements :: (Warnings), constraints_Inh_Statements :: (ConstraintSet), counter_Inh_Statements :: (Int), currentChunk_Inh_Statements :: (Int), dictionaryEnvironment_Inh_Statements :: (DictionaryEnvironment), generatorBeta_Inh_Statements :: (Maybe Tp), importEnvironment_Inh_Statements :: (ImportEnvironment), matchIO_Inh_Statements :: (IO ()), monos_Inh_Statements :: (Monos), namesInScope_Inh_Statements :: (Names), orderedTypeSynonyms_Inh_Statements :: (OrderedTypeSynonyms), parentTree_Inh_Statements :: (InfoTree), patternMatchWarnings_Inh_Statements :: ([Warning]), substitution_Inh_Statements :: (FixpointSubstitution), typeschemeMap_Inh_Statements :: (M.Map Int (Scheme Predicates)), unboundNames_Inh_Statements :: (Names), uniqueChunk_Inh_Statements :: (Int), uniqueSecondRound_Inh_Statements :: (Int) }
data Syn_Statements  = Syn_Statements { assumptions_Syn_Statements :: (Assumptions), betaUnique_Syn_Statements :: (Int), collectErrors_Syn_Statements :: (TypeErrors), collectInstances_Syn_Statements :: ([(Name, Instance)]), collectWarnings_Syn_Statements :: (Warnings), constraints_Syn_Statements :: (ConstraintSet), counter_Syn_Statements :: (Int), dictionaryEnvironment_Syn_Statements :: (DictionaryEnvironment), generatorBeta_Syn_Statements :: (Maybe Tp), infoTrees_Syn_Statements :: (InfoTrees), matchIO_Syn_Statements :: (IO ()), namesInScope_Syn_Statements :: (Names), patternMatchWarnings_Syn_Statements :: ([Warning]), self_Syn_Statements :: (Statements), unboundNames_Syn_Statements :: (Names), uniqueChunk_Syn_Statements :: (Int), uniqueSecondRound_Syn_Statements :: (Int) }
{-# INLINABLE wrap_Statements #-}
wrap_Statements :: T_Statements  -> Inh_Statements  -> (Syn_Statements )
wrap_Statements (T_Statements act) (Inh_Statements _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Statements_vIn157 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound
        (T_Statements_vOut157 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound) <- return (inv_Statements_s158 sem arg)
        return (Syn_Statements _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound)
   )

-- cata
{-# NOINLINE sem_Statements #-}
sem_Statements :: Statements  -> T_Statements 
sem_Statements list = Prelude.foldr sem_Statements_Cons sem_Statements_Nil (Prelude.map sem_Statement list)

-- semantic domain
newtype T_Statements  = T_Statements {
                                     attach_T_Statements :: Identity (T_Statements_s158 )
                                     }
newtype T_Statements_s158  = C_Statements_s158 {
                                               inv_Statements_s158 :: (T_Statements_v157 )
                                               }
data T_Statements_s159  = C_Statements_s159
type T_Statements_v157  = (T_Statements_vIn157 ) -> (T_Statements_vOut157 )
data T_Statements_vIn157  = T_Statements_vIn157 ([((Expression, [String]), Core_TypingStrategy)]) (M.Map NameWithRange TpScheme) (Assumptions) (Predicates) (Int) (ClassEnvironment) (TypeErrors) (Warnings) (ConstraintSet) (Int) (Int) (DictionaryEnvironment) (Maybe Tp) (ImportEnvironment) (IO ()) (Monos) (Names) (OrderedTypeSynonyms) (InfoTree) ([Warning]) (FixpointSubstitution) (M.Map Int (Scheme Predicates)) (Names) (Int) (Int)
data T_Statements_vOut157  = T_Statements_vOut157 (Assumptions) (Int) (TypeErrors) ([(Name, Instance)]) (Warnings) (ConstraintSet) (Int) (DictionaryEnvironment) (Maybe Tp) (InfoTrees) (IO ()) (Names) ([Warning]) (Statements) (Names) (Int) (Int)
{-# NOINLINE sem_Statements_Cons #-}
sem_Statements_Cons :: T_Statement  -> T_Statements  -> T_Statements 
sem_Statements_Cons arg_hd_ arg_tl_ = T_Statements (return st158) where
   {-# NOINLINE st158 #-}
   st158 = let
      v157 :: T_Statements_v157 
      v157 = \ (T_Statements_vIn157 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _hdX155 = Control.Monad.Identity.runIdentity (attach_T_Statement (arg_hd_))
         _tlX158 = Control.Monad.Identity.runIdentity (attach_T_Statements (arg_tl_))
         (T_Statement_vOut154 _hdIassumptions _hdIbetaUnique _hdIcollectErrors _hdIcollectInstances _hdIcollectWarnings _hdIconstraints _hdIcounter _hdIdictionaryEnvironment _hdIgeneratorBeta _hdIinfoTree _hdImatchIO _hdImonos _hdInamesInScope _hdIpatternMatchWarnings _hdIself _hdIunboundNames _hdIuniqueChunk _hdIuniqueSecondRound) = inv_Statement_s155 _hdX155 (T_Statement_vIn154 _hdOallPatterns _hdOallTypeSchemes _hdOassumptions _hdOavailablePredicates _hdObetaUnique _hdOclassEnvironment _hdOcollectErrors _hdOcollectWarnings _hdOconstraints _hdOcounter _hdOcurrentChunk _hdOdictionaryEnvironment _hdOgeneratorBeta _hdOimportEnvironment _hdOmatchIO _hdOmonos _hdOnamesInScope _hdOorderedTypeSynonyms _hdOparentTree _hdOpatternMatchWarnings _hdOsubstitution _hdOtypeschemeMap _hdOunboundNames _hdOuniqueChunk _hdOuniqueSecondRound)
         (T_Statements_vOut157 _tlIassumptions _tlIbetaUnique _tlIcollectErrors _tlIcollectInstances _tlIcollectWarnings _tlIconstraints _tlIcounter _tlIdictionaryEnvironment _tlIgeneratorBeta _tlIinfoTrees _tlImatchIO _tlInamesInScope _tlIpatternMatchWarnings _tlIself _tlIunboundNames _tlIuniqueChunk _tlIuniqueSecondRound) = inv_Statements_s158 _tlX158 (T_Statements_vIn157 _tlOallPatterns _tlOallTypeSchemes _tlOassumptions _tlOavailablePredicates _tlObetaUnique _tlOclassEnvironment _tlOcollectErrors _tlOcollectWarnings _tlOconstraints _tlOcounter _tlOcurrentChunk _tlOdictionaryEnvironment _tlOgeneratorBeta _tlOimportEnvironment _tlOmatchIO _tlOmonos _tlOnamesInScope _tlOorderedTypeSynonyms _tlOparentTree _tlOpatternMatchWarnings _tlOsubstitution _tlOtypeschemeMap _tlOunboundNames _tlOuniqueChunk _tlOuniqueSecondRound)
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3744 _hdIassumptions
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3745 _hdIconstraints
         _hdOassumptions = rule3746 _tlIassumptions
         _hdOconstraints = rule3747 _tlIconstraints
         _tlOassumptions = rule3748 _lhsIassumptions
         _tlOconstraints = rule3749 _lhsIconstraints
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule3750 _hdIinfoTree _tlIinfoTrees
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3751 _hdIunboundNames
         _tlOunboundNames = rule3752 _lhsIunboundNames
         _hdOunboundNames = rule3753 _tlIunboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3754 _hdIcollectInstances _tlIcollectInstances
         _self = rule3755 _hdIself _tlIself
         _lhsOself :: Statements
         _lhsOself = rule3756 _self
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3757 _tlIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3758 _tlIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3759 _tlIcollectWarnings
         _lhsOcounter :: Int
         _lhsOcounter = rule3760 _tlIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3761 _tlIdictionaryEnvironment
         _lhsOgeneratorBeta :: Maybe Tp
         _lhsOgeneratorBeta = rule3762 _tlIgeneratorBeta
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3763 _tlImatchIO
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3764 _tlInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3765 _tlIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3766 _tlIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3767 _tlIuniqueSecondRound
         _hdOallPatterns = rule3768 _lhsIallPatterns
         _hdOallTypeSchemes = rule3769 _lhsIallTypeSchemes
         _hdOavailablePredicates = rule3770 _lhsIavailablePredicates
         _hdObetaUnique = rule3771 _lhsIbetaUnique
         _hdOclassEnvironment = rule3772 _lhsIclassEnvironment
         _hdOcollectErrors = rule3773 _lhsIcollectErrors
         _hdOcollectWarnings = rule3774 _lhsIcollectWarnings
         _hdOcounter = rule3775 _lhsIcounter
         _hdOcurrentChunk = rule3776 _lhsIcurrentChunk
         _hdOdictionaryEnvironment = rule3777 _lhsIdictionaryEnvironment
         _hdOgeneratorBeta = rule3778 _lhsIgeneratorBeta
         _hdOimportEnvironment = rule3779 _lhsIimportEnvironment
         _hdOmatchIO = rule3780 _lhsImatchIO
         _hdOmonos = rule3781 _lhsImonos
         _hdOnamesInScope = rule3782 _lhsInamesInScope
         _hdOorderedTypeSynonyms = rule3783 _lhsIorderedTypeSynonyms
         _hdOparentTree = rule3784 _lhsIparentTree
         _hdOpatternMatchWarnings = rule3785 _lhsIpatternMatchWarnings
         _hdOsubstitution = rule3786 _lhsIsubstitution
         _hdOtypeschemeMap = rule3787 _lhsItypeschemeMap
         _hdOuniqueChunk = rule3788 _lhsIuniqueChunk
         _hdOuniqueSecondRound = rule3789 _lhsIuniqueSecondRound
         _tlOallPatterns = rule3790 _lhsIallPatterns
         _tlOallTypeSchemes = rule3791 _lhsIallTypeSchemes
         _tlOavailablePredicates = rule3792 _lhsIavailablePredicates
         _tlObetaUnique = rule3793 _hdIbetaUnique
         _tlOclassEnvironment = rule3794 _lhsIclassEnvironment
         _tlOcollectErrors = rule3795 _hdIcollectErrors
         _tlOcollectWarnings = rule3796 _hdIcollectWarnings
         _tlOcounter = rule3797 _hdIcounter
         _tlOcurrentChunk = rule3798 _lhsIcurrentChunk
         _tlOdictionaryEnvironment = rule3799 _hdIdictionaryEnvironment
         _tlOgeneratorBeta = rule3800 _hdIgeneratorBeta
         _tlOimportEnvironment = rule3801 _lhsIimportEnvironment
         _tlOmatchIO = rule3802 _hdImatchIO
         _tlOmonos = rule3803 _hdImonos
         _tlOnamesInScope = rule3804 _hdInamesInScope
         _tlOorderedTypeSynonyms = rule3805 _lhsIorderedTypeSynonyms
         _tlOparentTree = rule3806 _lhsIparentTree
         _tlOpatternMatchWarnings = rule3807 _hdIpatternMatchWarnings
         _tlOsubstitution = rule3808 _lhsIsubstitution
         _tlOtypeschemeMap = rule3809 _lhsItypeschemeMap
         _tlOuniqueChunk = rule3810 _hdIuniqueChunk
         _tlOuniqueSecondRound = rule3811 _hdIuniqueSecondRound
         __result_ = T_Statements_vOut157 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Statements_s158 v157
   {-# INLINE rule3744 #-}
   rule3744 = \ ((_hdIassumptions) :: Assumptions) ->
                            _hdIassumptions
   {-# INLINE rule3745 #-}
   rule3745 = \ ((_hdIconstraints) :: ConstraintSet) ->
                            _hdIconstraints
   {-# INLINE rule3746 #-}
   rule3746 = \ ((_tlIassumptions) :: Assumptions) ->
                            _tlIassumptions
   {-# INLINE rule3747 #-}
   rule3747 = \ ((_tlIconstraints) :: ConstraintSet) ->
                            _tlIconstraints
   {-# INLINE rule3748 #-}
   rule3748 = \ ((_lhsIassumptions) :: Assumptions) ->
                            _lhsIassumptions
   {-# INLINE rule3749 #-}
   rule3749 = \ ((_lhsIconstraints) :: ConstraintSet) ->
                            _lhsIconstraints
   {-# INLINE rule3750 #-}
   rule3750 = \ ((_hdIinfoTree) :: InfoTree) ((_tlIinfoTrees) :: InfoTrees) ->
                               _hdIinfoTree : _tlIinfoTrees
   {-# INLINE rule3751 #-}
   rule3751 = \ ((_hdIunboundNames) :: Names) ->
                                  _hdIunboundNames
   {-# INLINE rule3752 #-}
   rule3752 = \ ((_lhsIunboundNames) :: Names) ->
                                  _lhsIunboundNames
   {-# INLINE rule3753 #-}
   rule3753 = \ ((_tlIunboundNames) :: Names) ->
                                  _tlIunboundNames
   {-# INLINE rule3754 #-}
   rule3754 = \ ((_hdIcollectInstances) :: [(Name, Instance)]) ((_tlIcollectInstances) :: [(Name, Instance)]) ->
     _hdIcollectInstances  ++  _tlIcollectInstances
   {-# INLINE rule3755 #-}
   rule3755 = \ ((_hdIself) :: Statement) ((_tlIself) :: Statements) ->
     (:) _hdIself _tlIself
   {-# INLINE rule3756 #-}
   rule3756 = \ _self ->
     _self
   {-# INLINE rule3757 #-}
   rule3757 = \ ((_tlIbetaUnique) :: Int) ->
     _tlIbetaUnique
   {-# INLINE rule3758 #-}
   rule3758 = \ ((_tlIcollectErrors) :: TypeErrors) ->
     _tlIcollectErrors
   {-# INLINE rule3759 #-}
   rule3759 = \ ((_tlIcollectWarnings) :: Warnings) ->
     _tlIcollectWarnings
   {-# INLINE rule3760 #-}
   rule3760 = \ ((_tlIcounter) :: Int) ->
     _tlIcounter
   {-# INLINE rule3761 #-}
   rule3761 = \ ((_tlIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _tlIdictionaryEnvironment
   {-# INLINE rule3762 #-}
   rule3762 = \ ((_tlIgeneratorBeta) :: Maybe Tp) ->
     _tlIgeneratorBeta
   {-# INLINE rule3763 #-}
   rule3763 = \ ((_tlImatchIO) :: IO ()) ->
     _tlImatchIO
   {-# INLINE rule3764 #-}
   rule3764 = \ ((_tlInamesInScope) :: Names) ->
     _tlInamesInScope
   {-# INLINE rule3765 #-}
   rule3765 = \ ((_tlIpatternMatchWarnings) :: [Warning]) ->
     _tlIpatternMatchWarnings
   {-# INLINE rule3766 #-}
   rule3766 = \ ((_tlIuniqueChunk) :: Int) ->
     _tlIuniqueChunk
   {-# INLINE rule3767 #-}
   rule3767 = \ ((_tlIuniqueSecondRound) :: Int) ->
     _tlIuniqueSecondRound
   {-# INLINE rule3768 #-}
   rule3768 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3769 #-}
   rule3769 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3770 #-}
   rule3770 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3771 #-}
   rule3771 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3772 #-}
   rule3772 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3773 #-}
   rule3773 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3774 #-}
   rule3774 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3775 #-}
   rule3775 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3776 #-}
   rule3776 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3777 #-}
   rule3777 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3778 #-}
   rule3778 = \ ((_lhsIgeneratorBeta) :: Maybe Tp) ->
     _lhsIgeneratorBeta
   {-# INLINE rule3779 #-}
   rule3779 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3780 #-}
   rule3780 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3781 #-}
   rule3781 = \ ((_lhsImonos) :: Monos) ->
     _lhsImonos
   {-# INLINE rule3782 #-}
   rule3782 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3783 #-}
   rule3783 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3784 #-}
   rule3784 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule3785 #-}
   rule3785 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3786 #-}
   rule3786 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3787 #-}
   rule3787 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3788 #-}
   rule3788 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3789 #-}
   rule3789 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound
   {-# INLINE rule3790 #-}
   rule3790 = \ ((_lhsIallPatterns) :: [((Expression, [String]), Core_TypingStrategy)]) ->
     _lhsIallPatterns
   {-# INLINE rule3791 #-}
   rule3791 = \ ((_lhsIallTypeSchemes) :: M.Map NameWithRange TpScheme) ->
     _lhsIallTypeSchemes
   {-# INLINE rule3792 #-}
   rule3792 = \ ((_lhsIavailablePredicates) :: Predicates) ->
     _lhsIavailablePredicates
   {-# INLINE rule3793 #-}
   rule3793 = \ ((_hdIbetaUnique) :: Int) ->
     _hdIbetaUnique
   {-# INLINE rule3794 #-}
   rule3794 = \ ((_lhsIclassEnvironment) :: ClassEnvironment) ->
     _lhsIclassEnvironment
   {-# INLINE rule3795 #-}
   rule3795 = \ ((_hdIcollectErrors) :: TypeErrors) ->
     _hdIcollectErrors
   {-# INLINE rule3796 #-}
   rule3796 = \ ((_hdIcollectWarnings) :: Warnings) ->
     _hdIcollectWarnings
   {-# INLINE rule3797 #-}
   rule3797 = \ ((_hdIcounter) :: Int) ->
     _hdIcounter
   {-# INLINE rule3798 #-}
   rule3798 = \ ((_lhsIcurrentChunk) :: Int) ->
     _lhsIcurrentChunk
   {-# INLINE rule3799 #-}
   rule3799 = \ ((_hdIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _hdIdictionaryEnvironment
   {-# INLINE rule3800 #-}
   rule3800 = \ ((_hdIgeneratorBeta) :: Maybe Tp) ->
     _hdIgeneratorBeta
   {-# INLINE rule3801 #-}
   rule3801 = \ ((_lhsIimportEnvironment) :: ImportEnvironment) ->
     _lhsIimportEnvironment
   {-# INLINE rule3802 #-}
   rule3802 = \ ((_hdImatchIO) :: IO ()) ->
     _hdImatchIO
   {-# INLINE rule3803 #-}
   rule3803 = \ ((_hdImonos) :: Monos) ->
     _hdImonos
   {-# INLINE rule3804 #-}
   rule3804 = \ ((_hdInamesInScope) :: Names) ->
     _hdInamesInScope
   {-# INLINE rule3805 #-}
   rule3805 = \ ((_lhsIorderedTypeSynonyms) :: OrderedTypeSynonyms) ->
     _lhsIorderedTypeSynonyms
   {-# INLINE rule3806 #-}
   rule3806 = \ ((_lhsIparentTree) :: InfoTree) ->
     _lhsIparentTree
   {-# INLINE rule3807 #-}
   rule3807 = \ ((_hdIpatternMatchWarnings) :: [Warning]) ->
     _hdIpatternMatchWarnings
   {-# INLINE rule3808 #-}
   rule3808 = \ ((_lhsIsubstitution) :: FixpointSubstitution) ->
     _lhsIsubstitution
   {-# INLINE rule3809 #-}
   rule3809 = \ ((_lhsItypeschemeMap) :: M.Map Int (Scheme Predicates)) ->
     _lhsItypeschemeMap
   {-# INLINE rule3810 #-}
   rule3810 = \ ((_hdIuniqueChunk) :: Int) ->
     _hdIuniqueChunk
   {-# INLINE rule3811 #-}
   rule3811 = \ ((_hdIuniqueSecondRound) :: Int) ->
     _hdIuniqueSecondRound
{-# NOINLINE sem_Statements_Nil #-}
sem_Statements_Nil ::  T_Statements 
sem_Statements_Nil  = T_Statements (return st158) where
   {-# NOINLINE st158 #-}
   st158 = let
      v157 :: T_Statements_v157 
      v157 = \ (T_Statements_vIn157 _lhsIallPatterns _lhsIallTypeSchemes _lhsIassumptions _lhsIavailablePredicates _lhsIbetaUnique _lhsIclassEnvironment _lhsIcollectErrors _lhsIcollectWarnings _lhsIconstraints _lhsIcounter _lhsIcurrentChunk _lhsIdictionaryEnvironment _lhsIgeneratorBeta _lhsIimportEnvironment _lhsImatchIO _lhsImonos _lhsInamesInScope _lhsIorderedTypeSynonyms _lhsIparentTree _lhsIpatternMatchWarnings _lhsIsubstitution _lhsItypeschemeMap _lhsIunboundNames _lhsIuniqueChunk _lhsIuniqueSecondRound) -> ( let
         _lhsOinfoTrees :: InfoTrees
         _lhsOinfoTrees = rule3812  ()
         _lhsOunboundNames :: Names
         _lhsOunboundNames = rule3813 _lhsIunboundNames
         _lhsOcollectInstances :: [(Name, Instance)]
         _lhsOcollectInstances = rule3814  ()
         _self = rule3815  ()
         _lhsOself :: Statements
         _lhsOself = rule3816 _self
         _lhsOassumptions :: Assumptions
         _lhsOassumptions = rule3817 _lhsIassumptions
         _lhsObetaUnique :: Int
         _lhsObetaUnique = rule3818 _lhsIbetaUnique
         _lhsOcollectErrors :: TypeErrors
         _lhsOcollectErrors = rule3819 _lhsIcollectErrors
         _lhsOcollectWarnings :: Warnings
         _lhsOcollectWarnings = rule3820 _lhsIcollectWarnings
         _lhsOconstraints :: ConstraintSet
         _lhsOconstraints = rule3821 _lhsIconstraints
         _lhsOcounter :: Int
         _lhsOcounter = rule3822 _lhsIcounter
         _lhsOdictionaryEnvironment :: DictionaryEnvironment
         _lhsOdictionaryEnvironment = rule3823 _lhsIdictionaryEnvironment
         _lhsOgeneratorBeta :: Maybe Tp
         _lhsOgeneratorBeta = rule3824 _lhsIgeneratorBeta
         _lhsOmatchIO :: IO ()
         _lhsOmatchIO = rule3825 _lhsImatchIO
         _lhsOnamesInScope :: Names
         _lhsOnamesInScope = rule3826 _lhsInamesInScope
         _lhsOpatternMatchWarnings :: [Warning]
         _lhsOpatternMatchWarnings = rule3827 _lhsIpatternMatchWarnings
         _lhsOuniqueChunk :: Int
         _lhsOuniqueChunk = rule3828 _lhsIuniqueChunk
         _lhsOuniqueSecondRound :: Int
         _lhsOuniqueSecondRound = rule3829 _lhsIuniqueSecondRound
         __result_ = T_Statements_vOut157 _lhsOassumptions _lhsObetaUnique _lhsOcollectErrors _lhsOcollectInstances _lhsOcollectWarnings _lhsOconstraints _lhsOcounter _lhsOdictionaryEnvironment _lhsOgeneratorBeta _lhsOinfoTrees _lhsOmatchIO _lhsOnamesInScope _lhsOpatternMatchWarnings _lhsOself _lhsOunboundNames _lhsOuniqueChunk _lhsOuniqueSecondRound
         in __result_ )
     in C_Statements_s158 v157
   {-# INLINE rule3812 #-}
   rule3812 = \  (_ :: ()) ->
                               []
   {-# INLINE rule3813 #-}
   rule3813 = \ ((_lhsIunboundNames) :: Names) ->
                                  _lhsIunboundNames
   {-# INLINE rule3814 #-}
   rule3814 = \  (_ :: ()) ->
     []
   {-# INLINE rule3815 #-}
   rule3815 = \  (_ :: ()) ->
     []
   {-# INLINE rule3816 #-}
   rule3816 = \ _self ->
     _self
   {-# INLINE rule3817 #-}
   rule3817 = \ ((_lhsIassumptions) :: Assumptions) ->
     _lhsIassumptions
   {-# INLINE rule3818 #-}
   rule3818 = \ ((_lhsIbetaUnique) :: Int) ->
     _lhsIbetaUnique
   {-# INLINE rule3819 #-}
   rule3819 = \ ((_lhsIcollectErrors) :: TypeErrors) ->
     _lhsIcollectErrors
   {-# INLINE rule3820 #-}
   rule3820 = \ ((_lhsIcollectWarnings) :: Warnings) ->
     _lhsIcollectWarnings
   {-# INLINE rule3821 #-}
   rule3821 = \ ((_lhsIconstraints) :: ConstraintSet) ->
     _lhsIconstraints
   {-# INLINE rule3822 #-}
   rule3822 = \ ((_lhsIcounter) :: Int) ->
     _lhsIcounter
   {-# INLINE rule3823 #-}
   rule3823 = \ ((_lhsIdictionaryEnvironment) :: DictionaryEnvironment) ->
     _lhsIdictionaryEnvironment
   {-# INLINE rule3824 #-}
   rule3824 = \ ((_lhsIgeneratorBeta) :: Maybe Tp) ->
     _lhsIgeneratorBeta
   {-# INLINE rule3825 #-}
   rule3825 = \ ((_lhsImatchIO) :: IO ()) ->
     _lhsImatchIO
   {-# INLINE rule3826 #-}
   rule3826 = \ ((_lhsInamesInScope) :: Names) ->
     _lhsInamesInScope
   {-# INLINE rule3827 #-}
   rule3827 = \ ((_lhsIpatternMatchWarnings) :: [Warning]) ->
     _lhsIpatternMatchWarnings
   {-# INLINE rule3828 #-}
   rule3828 = \ ((_lhsIuniqueChunk) :: Int) ->
     _lhsIuniqueChunk
   {-# INLINE rule3829 #-}
   rule3829 = \ ((_lhsIuniqueSecondRound) :: Int) ->
     _lhsIuniqueSecondRound

-- Strings -----------------------------------------------------
-- wrapper
data Inh_Strings  = Inh_Strings {  }
data Syn_Strings  = Syn_Strings { self_Syn_Strings :: (Strings) }
{-# INLINABLE wrap_Strings #-}
wrap_Strings :: T_Strings  -> Inh_Strings  -> (Syn_Strings )
wrap_Strings (T_Strings act) (Inh_Strings ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Strings_vIn160 
        (T_Strings_vOut160 _lhsOself) <- return (inv_Strings_s161 sem arg)
        return (Syn_Strings _lhsOself)
   )

-- cata
{-# NOINLINE sem_Strings #-}
sem_Strings :: Strings  -> T_Strings 
sem_Strings list = Prelude.foldr sem_Strings_Cons sem_Strings_Nil list

-- semantic domain
newtype T_Strings  = T_Strings {
                               attach_T_Strings :: Identity (T_Strings_s161 )
                               }
newtype T_Strings_s161  = C_Strings_s161 {
                                         inv_Strings_s161 :: (T_Strings_v160 )
                                         }
data T_Strings_s162  = C_Strings_s162
type T_Strings_v160  = (T_Strings_vIn160 ) -> (T_Strings_vOut160 )
data T_Strings_vIn160  = T_Strings_vIn160 
data T_Strings_vOut160  = T_Strings_vOut160 (Strings)
{-# NOINLINE sem_Strings_Cons #-}
sem_Strings_Cons :: (String) -> T_Strings  -> T_Strings 
sem_Strings_Cons arg_hd_ arg_tl_ = T_Strings (return st161) where
   {-# NOINLINE st161 #-}
   st161 = let
      v160 :: T_Strings_v160 
      v160 = \ (T_Strings_vIn160 ) -> ( let
         _tlX161 = Control.Monad.Identity.runIdentity (attach_T_Strings (arg_tl_))
         (T_Strings_vOut160 _tlIself) = inv_Strings_s161 _tlX161 (T_Strings_vIn160 )
         _self = rule3830 _tlIself arg_hd_
         _lhsOself :: Strings
         _lhsOself = rule3831 _self
         __result_ = T_Strings_vOut160 _lhsOself
         in __result_ )
     in C_Strings_s161 v160
   {-# INLINE rule3830 #-}
   rule3830 = \ ((_tlIself) :: Strings) hd_ ->
     (:) hd_ _tlIself
   {-# INLINE rule3831 #-}
   rule3831 = \ _self ->
     _self
{-# NOINLINE sem_Strings_Nil #-}
sem_Strings_Nil ::  T_Strings 
sem_Strings_Nil  = T_Strings (return st161) where
   {-# NOINLINE st161 #-}
   st161 = let
      v160 :: T_Strings_v160 
      v160 = \ (T_Strings_vIn160 ) -> ( let
         _self = rule3832  ()
         _lhsOself :: Strings
         _lhsOself = rule3833 _self
         __result_ = T_Strings_vOut160 _lhsOself
         in __result_ )
     in C_Strings_s161 v160
   {-# INLINE rule3832 #-}
   rule3832 = \  (_ :: ()) ->
     []
   {-# INLINE rule3833 #-}
   rule3833 = \ _self ->
     _self

-- Type --------------------------------------------------------
-- wrapper
data Inh_Type  = Inh_Type {  }
data Syn_Type  = Syn_Type { self_Syn_Type :: (Type) }
{-# INLINABLE wrap_Type #-}
wrap_Type :: T_Type  -> Inh_Type  -> (Syn_Type )
wrap_Type (T_Type act) (Inh_Type ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Type_vIn163 
        (T_Type_vOut163 _lhsOself) <- return (inv_Type_s164 sem arg)
        return (Syn_Type _lhsOself)
   )

-- cata
{-# NOINLINE sem_Type #-}
sem_Type :: Type  -> T_Type 
sem_Type ( Type_Application range_ prefix_ function_ arguments_ ) = sem_Type_Application ( sem_Range range_ ) prefix_ ( sem_Type function_ ) ( sem_Types arguments_ )
sem_Type ( Type_Variable range_ name_ ) = sem_Type_Variable ( sem_Range range_ ) ( sem_Name name_ )
sem_Type ( Type_Constructor range_ name_ ) = sem_Type_Constructor ( sem_Range range_ ) ( sem_Name name_ )
sem_Type ( Type_Qualified range_ context_ type_ ) = sem_Type_Qualified ( sem_Range range_ ) ( sem_ContextItems context_ ) ( sem_Type type_ )
sem_Type ( Type_Forall range_ typevariables_ type_ ) = sem_Type_Forall ( sem_Range range_ ) ( sem_Names typevariables_ ) ( sem_Type type_ )
sem_Type ( Type_Exists range_ typevariables_ type_ ) = sem_Type_Exists ( sem_Range range_ ) ( sem_Names typevariables_ ) ( sem_Type type_ )
sem_Type ( Type_Parenthesized range_ type_ ) = sem_Type_Parenthesized ( sem_Range range_ ) ( sem_Type type_ )

-- semantic domain
newtype T_Type  = T_Type {
                         attach_T_Type :: Identity (T_Type_s164 )
                         }
newtype T_Type_s164  = C_Type_s164 {
                                   inv_Type_s164 :: (T_Type_v163 )
                                   }
data T_Type_s165  = C_Type_s165
type T_Type_v163  = (T_Type_vIn163 ) -> (T_Type_vOut163 )
data T_Type_vIn163  = T_Type_vIn163 
data T_Type_vOut163  = T_Type_vOut163 (Type)
{-# NOINLINE sem_Type_Application #-}
sem_Type_Application :: T_Range  -> (Bool) -> T_Type  -> T_Types  -> T_Type 
sem_Type_Application arg_range_ arg_prefix_ arg_function_ arg_arguments_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _functionX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_function_))
         _argumentsX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_arguments_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Type_vOut163 _functionIself) = inv_Type_s164 _functionX164 (T_Type_vIn163 )
         (T_Types_vOut166 _argumentsIself) = inv_Types_s167 _argumentsX167 (T_Types_vIn166 )
         _self = rule3834 _argumentsIself _functionIself _rangeIself arg_prefix_
         _lhsOself :: Type
         _lhsOself = rule3835 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3834 #-}
   rule3834 = \ ((_argumentsIself) :: Types) ((_functionIself) :: Type) ((_rangeIself) :: Range) prefix_ ->
     Type_Application _rangeIself prefix_ _functionIself _argumentsIself
   {-# INLINE rule3835 #-}
   rule3835 = \ _self ->
     _self
{-# NOINLINE sem_Type_Variable #-}
sem_Type_Variable :: T_Range  -> T_Name  -> T_Type 
sem_Type_Variable arg_range_ arg_name_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule3836 _nameIself _rangeIself
         _lhsOself :: Type
         _lhsOself = rule3837 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3836 #-}
   rule3836 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Type_Variable _rangeIself _nameIself
   {-# INLINE rule3837 #-}
   rule3837 = \ _self ->
     _self
{-# NOINLINE sem_Type_Constructor #-}
sem_Type_Constructor :: T_Range  -> T_Name  -> T_Type 
sem_Type_Constructor arg_range_ arg_name_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _nameX113 = Control.Monad.Identity.runIdentity (attach_T_Name (arg_name_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Name_vOut112 _nameIself) = inv_Name_s113 _nameX113 (T_Name_vIn112 )
         _self = rule3838 _nameIself _rangeIself
         _lhsOself :: Type
         _lhsOself = rule3839 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3838 #-}
   rule3838 = \ ((_nameIself) :: Name) ((_rangeIself) :: Range) ->
     Type_Constructor _rangeIself _nameIself
   {-# INLINE rule3839 #-}
   rule3839 = \ _self ->
     _self
{-# NOINLINE sem_Type_Qualified #-}
sem_Type_Qualified :: T_Range  -> T_ContextItems  -> T_Type  -> T_Type 
sem_Type_Qualified arg_range_ arg_context_ arg_type_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _contextX26 = Control.Monad.Identity.runIdentity (attach_T_ContextItems (arg_context_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_ContextItems_vOut25 _contextIself) = inv_ContextItems_s26 _contextX26 (T_ContextItems_vIn25 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _self = rule3840 _contextIself _rangeIself _typeIself
         _lhsOself :: Type
         _lhsOself = rule3841 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3840 #-}
   rule3840 = \ ((_contextIself) :: ContextItems) ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
     Type_Qualified _rangeIself _contextIself _typeIself
   {-# INLINE rule3841 #-}
   rule3841 = \ _self ->
     _self
{-# NOINLINE sem_Type_Forall #-}
sem_Type_Forall :: T_Range  -> T_Names  -> T_Type  -> T_Type 
sem_Type_Forall arg_range_ arg_typevariables_ arg_type_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _typevariablesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_typevariables_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Names_vOut115 _typevariablesIself) = inv_Names_s116 _typevariablesX116 (T_Names_vIn115 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _self = rule3842 _rangeIself _typeIself _typevariablesIself
         _lhsOself :: Type
         _lhsOself = rule3843 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3842 #-}
   rule3842 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) ((_typevariablesIself) :: Names) ->
     Type_Forall _rangeIself _typevariablesIself _typeIself
   {-# INLINE rule3843 #-}
   rule3843 = \ _self ->
     _self
{-# NOINLINE sem_Type_Exists #-}
sem_Type_Exists :: T_Range  -> T_Names  -> T_Type  -> T_Type 
sem_Type_Exists arg_range_ arg_typevariables_ arg_type_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _typevariablesX116 = Control.Monad.Identity.runIdentity (attach_T_Names (arg_typevariables_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Names_vOut115 _typevariablesIself) = inv_Names_s116 _typevariablesX116 (T_Names_vIn115 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _self = rule3844 _rangeIself _typeIself _typevariablesIself
         _lhsOself :: Type
         _lhsOself = rule3845 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3844 #-}
   rule3844 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) ((_typevariablesIself) :: Names) ->
     Type_Exists _rangeIself _typevariablesIself _typeIself
   {-# INLINE rule3845 #-}
   rule3845 = \ _self ->
     _self
{-# NOINLINE sem_Type_Parenthesized #-}
sem_Type_Parenthesized :: T_Range  -> T_Type  -> T_Type 
sem_Type_Parenthesized arg_range_ arg_type_ = T_Type (return st164) where
   {-# NOINLINE st164 #-}
   st164 = let
      v163 :: T_Type_v163 
      v163 = \ (T_Type_vIn163 ) -> ( let
         _rangeX134 = Control.Monad.Identity.runIdentity (attach_T_Range (arg_range_))
         _typeX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_type_))
         (T_Range_vOut133 _rangeIself) = inv_Range_s134 _rangeX134 (T_Range_vIn133 )
         (T_Type_vOut163 _typeIself) = inv_Type_s164 _typeX164 (T_Type_vIn163 )
         _self = rule3846 _rangeIself _typeIself
         _lhsOself :: Type
         _lhsOself = rule3847 _self
         __result_ = T_Type_vOut163 _lhsOself
         in __result_ )
     in C_Type_s164 v163
   {-# INLINE rule3846 #-}
   rule3846 = \ ((_rangeIself) :: Range) ((_typeIself) :: Type) ->
     Type_Parenthesized _rangeIself _typeIself
   {-# INLINE rule3847 #-}
   rule3847 = \ _self ->
     _self

-- Types -------------------------------------------------------
-- wrapper
data Inh_Types  = Inh_Types {  }
data Syn_Types  = Syn_Types { self_Syn_Types :: (Types) }
{-# INLINABLE wrap_Types #-}
wrap_Types :: T_Types  -> Inh_Types  -> (Syn_Types )
wrap_Types (T_Types act) (Inh_Types ) =
   Control.Monad.Identity.runIdentity (
     do sem <- act
        let arg = T_Types_vIn166 
        (T_Types_vOut166 _lhsOself) <- return (inv_Types_s167 sem arg)
        return (Syn_Types _lhsOself)
   )

-- cata
{-# NOINLINE sem_Types #-}
sem_Types :: Types  -> T_Types 
sem_Types list = Prelude.foldr sem_Types_Cons sem_Types_Nil (Prelude.map sem_Type list)

-- semantic domain
newtype T_Types  = T_Types {
                           attach_T_Types :: Identity (T_Types_s167 )
                           }
newtype T_Types_s167  = C_Types_s167 {
                                     inv_Types_s167 :: (T_Types_v166 )
                                     }
data T_Types_s168  = C_Types_s168
type T_Types_v166  = (T_Types_vIn166 ) -> (T_Types_vOut166 )
data T_Types_vIn166  = T_Types_vIn166 
data T_Types_vOut166  = T_Types_vOut166 (Types)
{-# NOINLINE sem_Types_Cons #-}
sem_Types_Cons :: T_Type  -> T_Types  -> T_Types 
sem_Types_Cons arg_hd_ arg_tl_ = T_Types (return st167) where
   {-# NOINLINE st167 #-}
   st167 = let
      v166 :: T_Types_v166 
      v166 = \ (T_Types_vIn166 ) -> ( let
         _hdX164 = Control.Monad.Identity.runIdentity (attach_T_Type (arg_hd_))
         _tlX167 = Control.Monad.Identity.runIdentity (attach_T_Types (arg_tl_))
         (T_Type_vOut163 _hdIself) = inv_Type_s164 _hdX164 (T_Type_vIn163 )
         (T_Types_vOut166 _tlIself) = inv_Types_s167 _tlX167 (T_Types_vIn166 )
         _self = rule3848 _hdIself _tlIself
         _lhsOself :: Types
         _lhsOself = rule3849 _self
         __result_ = T_Types_vOut166 _lhsOself
         in __result_ )
     in C_Types_s167 v166
   {-# INLINE rule3848 #-}
   rule3848 = \ ((_hdIself) :: Type) ((_tlIself) :: Types) ->
     (:) _hdIself _tlIself
   {-# INLINE rule3849 #-}
   rule3849 = \ _self ->
     _self
{-# NOINLINE sem_Types_Nil #-}
sem_Types_Nil ::  T_Types 
sem_Types_Nil  = T_Types (return st167) where
   {-# NOINLINE st167 #-}
   st167 = let
      v166 :: T_Types_v166 
      v166 = \ (T_Types_vIn166 ) -> ( let
         _self = rule3850  ()
         _lhsOself :: Types
         _lhsOself = rule3851 _self
         __result_ = T_Types_vOut166 _lhsOself
         in __result_ )
     in C_Types_s167 v166
   {-# INLINE rule3850 #-}
   rule3850 = \  (_ :: ()) ->
     []
   {-# INLINE rule3851 #-}
   rule3851 = \ _self ->
     _self