packages feed

clafer 0.3.6.1 → 0.3.7

raw patch · 41 files changed

+4287/−4633 lines, 41 filesdep +tastydep +tasty-hunitdep +tasty-thdep −test-frameworkdep −test-framework-hunitdep −test-framework-quickcheck2dep ~aesondep ~claferPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: tasty, tasty-hunit, tasty-th

Dependencies removed: test-framework, test-framework-hunit, test-framework-quickcheck2, test-framework-th

Dependency ranges changed: aeson, clafer

API changes (from Hackage documentation)

- Language.Clafer: PosPos :: Span -> Integer -> Integer -> Pos
- Language.Clafer.Front.Absclafer: PosAbstract :: Span -> Abstract
- Language.Clafer.Front.Absclafer: PosAbstractEmpty :: Span -> Abstract
- Language.Clafer.Front.Absclafer: PosCardAny :: Span -> Card
- Language.Clafer.Front.Absclafer: PosCardEmpty :: Span -> Card
- Language.Clafer.Front.Absclafer: PosCardInterval :: Span -> NCard -> Card
- Language.Clafer.Front.Absclafer: PosCardLone :: Span -> Card
- Language.Clafer.Front.Absclafer: PosCardNum :: Span -> PosInteger -> Card
- Language.Clafer.Front.Absclafer: PosCardSome :: Span -> Card
- Language.Clafer.Front.Absclafer: PosClafer :: Span -> Abstract -> GCard -> PosIdent -> Super -> Card -> Init -> Elements -> Clafer
- Language.Clafer.Front.Absclafer: PosClaferId :: Span -> Name -> SetExp
- Language.Clafer.Front.Absclafer: PosClaferUse :: Span -> Name -> Card -> Elements -> Element
- Language.Clafer.Front.Absclafer: PosConstraint :: Span -> [Exp] -> Constraint
- Language.Clafer.Front.Absclafer: PosDecl :: Span -> [LocId] -> SetExp -> Decl
- Language.Clafer.Front.Absclafer: PosDeclAll :: Span -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosDeclAllDisj :: Span -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosDeclQuant :: Span -> Quant -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosDeclQuantDisj :: Span -> Quant -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosDifference :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: PosDomain :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: PosEAdd :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEAnd :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosECSetExp :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEDiv :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEDouble :: Span -> PosDouble -> Exp
- Language.Clafer.Front.Absclafer: PosEEq :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEGMax :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEGMin :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEGt :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEGte :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEIff :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEImplies :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEImpliesElse :: Span -> Exp -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEIn :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEInt :: Span -> PosInteger -> Exp
- Language.Clafer.Front.Absclafer: PosELt :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosELte :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEMinExp :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEMul :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosENeg :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosENeq :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosENin :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEOr :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosESetExp :: Span -> SetExp -> Exp
- Language.Clafer.Front.Absclafer: PosEStr :: Span -> PosString -> Exp
- Language.Clafer.Front.Absclafer: PosESub :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosESumSetExp :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosEXor :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosElementDecl :: Span -> Element -> Declaration
- Language.Clafer.Front.Absclafer: PosElementsEmpty :: Span -> Elements
- Language.Clafer.Front.Absclafer: PosElementsList :: Span -> [Element] -> Elements
- Language.Clafer.Front.Absclafer: PosEnumDecl :: Span -> PosIdent -> [EnumId] -> Declaration
- Language.Clafer.Front.Absclafer: PosEnumIdIdent :: Span -> PosIdent -> EnumId
- Language.Clafer.Front.Absclafer: PosExIntegerAst :: Span -> ExInteger
- Language.Clafer.Front.Absclafer: PosExIntegerNum :: Span -> PosInteger -> ExInteger
- Language.Clafer.Front.Absclafer: PosGCardEmpty :: Span -> GCard
- Language.Clafer.Front.Absclafer: PosGCardInterval :: Span -> NCard -> GCard
- Language.Clafer.Front.Absclafer: PosGCardMux :: Span -> GCard
- Language.Clafer.Front.Absclafer: PosGCardOpt :: Span -> GCard
- Language.Clafer.Front.Absclafer: PosGCardOr :: Span -> GCard
- Language.Clafer.Front.Absclafer: PosGCardXor :: Span -> GCard
- Language.Clafer.Front.Absclafer: PosGoal :: Span -> [Exp] -> Goal
- Language.Clafer.Front.Absclafer: PosInitEmpty :: Span -> Init
- Language.Clafer.Front.Absclafer: PosInitHow_1 :: Span -> InitHow
- Language.Clafer.Front.Absclafer: PosInitHow_2 :: Span -> InitHow
- Language.Clafer.Front.Absclafer: PosInitSome :: Span -> InitHow -> Exp -> Init
- Language.Clafer.Front.Absclafer: PosIntersection :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: PosJoin :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: PosLocIdIdent :: Span -> PosIdent -> LocId
- Language.Clafer.Front.Absclafer: PosModIdIdent :: Span -> PosIdent -> ModId
- Language.Clafer.Front.Absclafer: PosModule :: Span -> [Declaration] -> Module
- Language.Clafer.Front.Absclafer: PosNCard :: Span -> PosInteger -> ExInteger -> NCard
- Language.Clafer.Front.Absclafer: PosPath :: Span -> [ModId] -> Name
- Language.Clafer.Front.Absclafer: PosPos :: Span -> Integer -> Integer -> Pos
- Language.Clafer.Front.Absclafer: PosQuantExp :: Span -> Quant -> Exp -> Exp
- Language.Clafer.Front.Absclafer: PosQuantLone :: Span -> Quant
- Language.Clafer.Front.Absclafer: PosQuantNo :: Span -> Quant
- Language.Clafer.Front.Absclafer: PosQuantOne :: Span -> Quant
- Language.Clafer.Front.Absclafer: PosQuantSome :: Span -> Quant
- Language.Clafer.Front.Absclafer: PosRange :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: PosSoftConstraint :: Span -> [Exp] -> SoftConstraint
- Language.Clafer.Front.Absclafer: PosSpan :: Span -> Pos -> Pos -> Span
- Language.Clafer.Front.Absclafer: PosSubclafer :: Span -> Clafer -> Element
- Language.Clafer.Front.Absclafer: PosSubconstraint :: Span -> Constraint -> Element
- Language.Clafer.Front.Absclafer: PosSubgoal :: Span -> Goal -> Element
- Language.Clafer.Front.Absclafer: PosSubsoftconstraint :: Span -> SoftConstraint -> Element
- Language.Clafer.Front.Absclafer: PosSuperArrow :: Span -> SuperHow
- Language.Clafer.Front.Absclafer: PosSuperColon :: Span -> SuperHow
- Language.Clafer.Front.Absclafer: PosSuperEmpty :: Span -> Super
- Language.Clafer.Front.Absclafer: PosSuperMArrow :: Span -> SuperHow
- Language.Clafer.Front.Absclafer: PosSuperSome :: Span -> SuperHow -> SetExp -> Super
- Language.Clafer.Front.Absclafer: PosUnion :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: PosUnionCom :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Lexclafer: AlexAccPred :: a -> (AlexAccPred user) -> AlexAcc a user
- Language.Clafer.Front.Lexclafer: AlexAccSkipPred :: (AlexAccPred user) -> AlexAcc a user
- Language.Clafer.Front.Lexclafer: alexAndPred :: (t -> t1 -> t2 -> t3 -> Bool) -> (t -> t1 -> t2 -> t3 -> Bool) -> t -> t1 -> t2 -> t3 -> Bool
- Language.Clafer.Front.Lexclafer: alexGetChar :: AlexInput -> Maybe (Char, AlexInput)
- Language.Clafer.Front.Lexclafer: alexPrevCharIs :: Char -> t -> AlexInput -> t1 -> t2 -> Bool
- Language.Clafer.Front.Lexclafer: alexPrevCharIsOneOf :: Array Char e -> t -> AlexInput -> t1 -> t2 -> e
- Language.Clafer.Front.Lexclafer: alexPrevCharMatches :: (Char -> t3) -> t -> AlexInput -> t1 -> t2 -> t3
- Language.Clafer.Front.Lexclafer: alexRightContext :: Int -> Any * -> t -> t1 -> (Posn, Char, String) -> Bool
- Language.Clafer.Front.Lexclafer: alex_action_9 :: Posn -> String -> Token
- Language.Clafer.Front.Lexclafer: type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool
- Language.Clafer.Front.Mapper: class Mappable n
- Language.Clafer.Front.Mapper: instance Mappable Abstract
- Language.Clafer.Front.Mapper: instance Mappable Card
- Language.Clafer.Front.Mapper: instance Mappable Clafer
- Language.Clafer.Front.Mapper: instance Mappable Constraint
- Language.Clafer.Front.Mapper: instance Mappable Decl
- Language.Clafer.Front.Mapper: instance Mappable Declaration
- Language.Clafer.Front.Mapper: instance Mappable Element
- Language.Clafer.Front.Mapper: instance Mappable Elements
- Language.Clafer.Front.Mapper: instance Mappable EnumId
- Language.Clafer.Front.Mapper: instance Mappable ExInteger
- Language.Clafer.Front.Mapper: instance Mappable Exp
- Language.Clafer.Front.Mapper: instance Mappable GCard
- Language.Clafer.Front.Mapper: instance Mappable Goal
- Language.Clafer.Front.Mapper: instance Mappable Init
- Language.Clafer.Front.Mapper: instance Mappable InitHow
- Language.Clafer.Front.Mapper: instance Mappable LocId
- Language.Clafer.Front.Mapper: instance Mappable ModId
- Language.Clafer.Front.Mapper: instance Mappable Module
- Language.Clafer.Front.Mapper: instance Mappable NCard
- Language.Clafer.Front.Mapper: instance Mappable Name
- Language.Clafer.Front.Mapper: instance Mappable PosDouble
- Language.Clafer.Front.Mapper: instance Mappable PosIdent
- Language.Clafer.Front.Mapper: instance Mappable PosInteger
- Language.Clafer.Front.Mapper: instance Mappable PosString
- Language.Clafer.Front.Mapper: instance Mappable Quant
- Language.Clafer.Front.Mapper: instance Mappable SetExp
- Language.Clafer.Front.Mapper: instance Mappable SoftConstraint
- Language.Clafer.Front.Mapper: instance Mappable Super
- Language.Clafer.Front.Mapper: instance Mappable SuperHow
- Language.Clafer.Front.Mapper: instance Mappable s => Mappable [s]
- Language.Clafer.Front.Mapper: mapModule :: Module -> Module
- Language.Clafer.Front.Mapper: mapNode :: Mappable n => n -> n
- Language.Clafer.Front.Mapper: range :: Mappable n => n -> Span
- Language.Clafer.Front.Parclafer: happyIn58 :: ([Exp]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn59 :: ([LocId]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn60 :: ([ModId]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyOut58 :: (HappyAbsSyn) -> ([Exp])
- Language.Clafer.Front.Parclafer: happyOut59 :: (HappyAbsSyn) -> ([LocId])
- Language.Clafer.Front.Parclafer: happyOut60 :: (HappyAbsSyn) -> ([ModId])
- Language.Clafer.Front.Parclafer: happyReduce_129 :: Int# -> Token -> Int# -> Happy_IntList -> HappyStk HappyAbsSyn -> [Token] -> Err HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduce_130 :: Int# -> Token -> Int# -> Happy_IntList -> HappyStk HappyAbsSyn -> [Token] -> Err HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_129 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_130 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Printclafer: instance Print Pos
- Language.Clafer.Front.Printclafer: instance Print Span
- Language.ClaferT: PosPos :: Span -> Integer -> Integer -> Pos
- Language.ClaferT: PosSpan :: Span -> Pos -> Pos -> Span
+ Language.Clafer: NoCompilerResult :: String -> CompilerResult
+ Language.Clafer: reason :: CompilerResult -> String
+ Language.Clafer.Common: realType :: String
+ Language.Clafer.Front.Absclafer: (>-) :: Span -> Span -> Span
+ Language.Clafer.Front.Absclafer: QuantNot :: Span -> Quant
+ Language.Clafer.Front.Absclafer: class Spannable n
+ Language.Clafer.Front.Absclafer: getSpan :: Spannable n => n -> Span
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Abstract
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Card
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Clafer
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Constraint
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Decl
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Declaration
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Element
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Elements
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0EnumId
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0ExInteger
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0GCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Goal
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Init
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0InitHow
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0LocId
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0ModId
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Module
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0NCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Name
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Pos
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0PosDouble
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0PosIdent
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0PosInteger
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0PosString
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Quant
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Span
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0Super
+ Language.Clafer.Front.Absclafer: instance Constructor C1_0SuperHow
+ Language.Clafer.Front.Absclafer: instance Constructor C1_10Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_11Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_12Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_13Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_14Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_15Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_16Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_17Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_18Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_19Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Abstract
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Card
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Declaration
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Element
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Elements
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1ExInteger
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1GCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Init
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1InitHow
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Quant
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1Super
+ Language.Clafer.Front.Absclafer: instance Constructor C1_1SuperHow
+ Language.Clafer.Front.Absclafer: instance Constructor C1_20Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_21Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_22Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_23Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_24Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_25Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_26Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_27Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_28Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_29Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2Card
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2Element
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2GCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2Quant
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_2SuperHow
+ Language.Clafer.Front.Absclafer: instance Constructor C1_30Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_31Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_32Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_3Card
+ Language.Clafer.Front.Absclafer: instance Constructor C1_3Element
+ Language.Clafer.Front.Absclafer: instance Constructor C1_3Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_3GCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_3Quant
+ Language.Clafer.Front.Absclafer: instance Constructor C1_3SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_4Card
+ Language.Clafer.Front.Absclafer: instance Constructor C1_4Element
+ Language.Clafer.Front.Absclafer: instance Constructor C1_4Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_4GCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_4Quant
+ Language.Clafer.Front.Absclafer: instance Constructor C1_4SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_5Card
+ Language.Clafer.Front.Absclafer: instance Constructor C1_5Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_5GCard
+ Language.Clafer.Front.Absclafer: instance Constructor C1_5SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_6Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_6SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_7Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_7SetExp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_8Exp
+ Language.Clafer.Front.Absclafer: instance Constructor C1_9Exp
+ Language.Clafer.Front.Absclafer: instance Data Abstract
+ Language.Clafer.Front.Absclafer: instance Data Card
+ Language.Clafer.Front.Absclafer: instance Data Clafer
+ Language.Clafer.Front.Absclafer: instance Data Constraint
+ Language.Clafer.Front.Absclafer: instance Data Decl
+ Language.Clafer.Front.Absclafer: instance Data Declaration
+ Language.Clafer.Front.Absclafer: instance Data Element
+ Language.Clafer.Front.Absclafer: instance Data Elements
+ Language.Clafer.Front.Absclafer: instance Data EnumId
+ Language.Clafer.Front.Absclafer: instance Data ExInteger
+ Language.Clafer.Front.Absclafer: instance Data Exp
+ Language.Clafer.Front.Absclafer: instance Data GCard
+ Language.Clafer.Front.Absclafer: instance Data Goal
+ Language.Clafer.Front.Absclafer: instance Data Init
+ Language.Clafer.Front.Absclafer: instance Data InitHow
+ Language.Clafer.Front.Absclafer: instance Data LocId
+ Language.Clafer.Front.Absclafer: instance Data ModId
+ Language.Clafer.Front.Absclafer: instance Data Module
+ Language.Clafer.Front.Absclafer: instance Data NCard
+ Language.Clafer.Front.Absclafer: instance Data Name
+ Language.Clafer.Front.Absclafer: instance Data PosDouble
+ Language.Clafer.Front.Absclafer: instance Data PosIdent
+ Language.Clafer.Front.Absclafer: instance Data PosInteger
+ Language.Clafer.Front.Absclafer: instance Data PosString
+ Language.Clafer.Front.Absclafer: instance Data Quant
+ Language.Clafer.Front.Absclafer: instance Data SetExp
+ Language.Clafer.Front.Absclafer: instance Data SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Data Super
+ Language.Clafer.Front.Absclafer: instance Data SuperHow
+ Language.Clafer.Front.Absclafer: instance Datatype D1Abstract
+ Language.Clafer.Front.Absclafer: instance Datatype D1Card
+ Language.Clafer.Front.Absclafer: instance Datatype D1Clafer
+ Language.Clafer.Front.Absclafer: instance Datatype D1Constraint
+ Language.Clafer.Front.Absclafer: instance Datatype D1Decl
+ Language.Clafer.Front.Absclafer: instance Datatype D1Declaration
+ Language.Clafer.Front.Absclafer: instance Datatype D1Element
+ Language.Clafer.Front.Absclafer: instance Datatype D1Elements
+ Language.Clafer.Front.Absclafer: instance Datatype D1EnumId
+ Language.Clafer.Front.Absclafer: instance Datatype D1ExInteger
+ Language.Clafer.Front.Absclafer: instance Datatype D1Exp
+ Language.Clafer.Front.Absclafer: instance Datatype D1GCard
+ Language.Clafer.Front.Absclafer: instance Datatype D1Goal
+ Language.Clafer.Front.Absclafer: instance Datatype D1Init
+ Language.Clafer.Front.Absclafer: instance Datatype D1InitHow
+ Language.Clafer.Front.Absclafer: instance Datatype D1LocId
+ Language.Clafer.Front.Absclafer: instance Datatype D1ModId
+ Language.Clafer.Front.Absclafer: instance Datatype D1Module
+ Language.Clafer.Front.Absclafer: instance Datatype D1NCard
+ Language.Clafer.Front.Absclafer: instance Datatype D1Name
+ Language.Clafer.Front.Absclafer: instance Datatype D1Pos
+ Language.Clafer.Front.Absclafer: instance Datatype D1PosDouble
+ Language.Clafer.Front.Absclafer: instance Datatype D1PosIdent
+ Language.Clafer.Front.Absclafer: instance Datatype D1PosInteger
+ Language.Clafer.Front.Absclafer: instance Datatype D1PosString
+ Language.Clafer.Front.Absclafer: instance Datatype D1Quant
+ Language.Clafer.Front.Absclafer: instance Datatype D1SetExp
+ Language.Clafer.Front.Absclafer: instance Datatype D1SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Datatype D1Span
+ Language.Clafer.Front.Absclafer: instance Datatype D1Super
+ Language.Clafer.Front.Absclafer: instance Datatype D1SuperHow
+ Language.Clafer.Front.Absclafer: instance Generic Abstract
+ Language.Clafer.Front.Absclafer: instance Generic Card
+ Language.Clafer.Front.Absclafer: instance Generic Clafer
+ Language.Clafer.Front.Absclafer: instance Generic Constraint
+ Language.Clafer.Front.Absclafer: instance Generic Decl
+ Language.Clafer.Front.Absclafer: instance Generic Declaration
+ Language.Clafer.Front.Absclafer: instance Generic Element
+ Language.Clafer.Front.Absclafer: instance Generic Elements
+ Language.Clafer.Front.Absclafer: instance Generic EnumId
+ Language.Clafer.Front.Absclafer: instance Generic ExInteger
+ Language.Clafer.Front.Absclafer: instance Generic Exp
+ Language.Clafer.Front.Absclafer: instance Generic GCard
+ Language.Clafer.Front.Absclafer: instance Generic Goal
+ Language.Clafer.Front.Absclafer: instance Generic Init
+ Language.Clafer.Front.Absclafer: instance Generic InitHow
+ Language.Clafer.Front.Absclafer: instance Generic LocId
+ Language.Clafer.Front.Absclafer: instance Generic ModId
+ Language.Clafer.Front.Absclafer: instance Generic Module
+ Language.Clafer.Front.Absclafer: instance Generic NCard
+ Language.Clafer.Front.Absclafer: instance Generic Name
+ Language.Clafer.Front.Absclafer: instance Generic Pos
+ Language.Clafer.Front.Absclafer: instance Generic PosDouble
+ Language.Clafer.Front.Absclafer: instance Generic PosIdent
+ Language.Clafer.Front.Absclafer: instance Generic PosInteger
+ Language.Clafer.Front.Absclafer: instance Generic PosString
+ Language.Clafer.Front.Absclafer: instance Generic Quant
+ Language.Clafer.Front.Absclafer: instance Generic SetExp
+ Language.Clafer.Front.Absclafer: instance Generic SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Generic Span
+ Language.Clafer.Front.Absclafer: instance Generic Super
+ Language.Clafer.Front.Absclafer: instance Generic SuperHow
+ Language.Clafer.Front.Absclafer: instance Read Abstract
+ Language.Clafer.Front.Absclafer: instance Read Card
+ Language.Clafer.Front.Absclafer: instance Read Clafer
+ Language.Clafer.Front.Absclafer: instance Read Constraint
+ Language.Clafer.Front.Absclafer: instance Read Decl
+ Language.Clafer.Front.Absclafer: instance Read Declaration
+ Language.Clafer.Front.Absclafer: instance Read Element
+ Language.Clafer.Front.Absclafer: instance Read Elements
+ Language.Clafer.Front.Absclafer: instance Read EnumId
+ Language.Clafer.Front.Absclafer: instance Read ExInteger
+ Language.Clafer.Front.Absclafer: instance Read Exp
+ Language.Clafer.Front.Absclafer: instance Read GCard
+ Language.Clafer.Front.Absclafer: instance Read Goal
+ Language.Clafer.Front.Absclafer: instance Read Init
+ Language.Clafer.Front.Absclafer: instance Read InitHow
+ Language.Clafer.Front.Absclafer: instance Read LocId
+ Language.Clafer.Front.Absclafer: instance Read ModId
+ Language.Clafer.Front.Absclafer: instance Read Module
+ Language.Clafer.Front.Absclafer: instance Read NCard
+ Language.Clafer.Front.Absclafer: instance Read Name
+ Language.Clafer.Front.Absclafer: instance Read Pos
+ Language.Clafer.Front.Absclafer: instance Read PosDouble
+ Language.Clafer.Front.Absclafer: instance Read PosIdent
+ Language.Clafer.Front.Absclafer: instance Read PosInteger
+ Language.Clafer.Front.Absclafer: instance Read PosString
+ Language.Clafer.Front.Absclafer: instance Read Quant
+ Language.Clafer.Front.Absclafer: instance Read SetExp
+ Language.Clafer.Front.Absclafer: instance Read SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Read Span
+ Language.Clafer.Front.Absclafer: instance Read Super
+ Language.Clafer.Front.Absclafer: instance Read SuperHow
+ Language.Clafer.Front.Absclafer: instance Spannable Abstract
+ Language.Clafer.Front.Absclafer: instance Spannable Card
+ Language.Clafer.Front.Absclafer: instance Spannable Clafer
+ Language.Clafer.Front.Absclafer: instance Spannable Constraint
+ Language.Clafer.Front.Absclafer: instance Spannable Decl
+ Language.Clafer.Front.Absclafer: instance Spannable Declaration
+ Language.Clafer.Front.Absclafer: instance Spannable Element
+ Language.Clafer.Front.Absclafer: instance Spannable Elements
+ Language.Clafer.Front.Absclafer: instance Spannable EnumId
+ Language.Clafer.Front.Absclafer: instance Spannable ExInteger
+ Language.Clafer.Front.Absclafer: instance Spannable Exp
+ Language.Clafer.Front.Absclafer: instance Spannable GCard
+ Language.Clafer.Front.Absclafer: instance Spannable Goal
+ Language.Clafer.Front.Absclafer: instance Spannable Init
+ Language.Clafer.Front.Absclafer: instance Spannable InitHow
+ Language.Clafer.Front.Absclafer: instance Spannable LocId
+ Language.Clafer.Front.Absclafer: instance Spannable ModId
+ Language.Clafer.Front.Absclafer: instance Spannable Module
+ Language.Clafer.Front.Absclafer: instance Spannable NCard
+ Language.Clafer.Front.Absclafer: instance Spannable Name
+ Language.Clafer.Front.Absclafer: instance Spannable PosDouble
+ Language.Clafer.Front.Absclafer: instance Spannable PosIdent
+ Language.Clafer.Front.Absclafer: instance Spannable PosInteger
+ Language.Clafer.Front.Absclafer: instance Spannable PosString
+ Language.Clafer.Front.Absclafer: instance Spannable Quant
+ Language.Clafer.Front.Absclafer: instance Spannable SetExp
+ Language.Clafer.Front.Absclafer: instance Spannable SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Spannable Super
+ Language.Clafer.Front.Absclafer: instance Spannable SuperHow
+ Language.Clafer.Front.Absclafer: instance Spannable n => Spannable [n]
+ Language.Clafer.Front.Absclafer: instance Typeable Abstract
+ Language.Clafer.Front.Absclafer: instance Typeable Card
+ Language.Clafer.Front.Absclafer: instance Typeable Clafer
+ Language.Clafer.Front.Absclafer: instance Typeable Constraint
+ Language.Clafer.Front.Absclafer: instance Typeable Decl
+ Language.Clafer.Front.Absclafer: instance Typeable Declaration
+ Language.Clafer.Front.Absclafer: instance Typeable Element
+ Language.Clafer.Front.Absclafer: instance Typeable Elements
+ Language.Clafer.Front.Absclafer: instance Typeable EnumId
+ Language.Clafer.Front.Absclafer: instance Typeable ExInteger
+ Language.Clafer.Front.Absclafer: instance Typeable Exp
+ Language.Clafer.Front.Absclafer: instance Typeable GCard
+ Language.Clafer.Front.Absclafer: instance Typeable Goal
+ Language.Clafer.Front.Absclafer: instance Typeable Init
+ Language.Clafer.Front.Absclafer: instance Typeable InitHow
+ Language.Clafer.Front.Absclafer: instance Typeable LocId
+ Language.Clafer.Front.Absclafer: instance Typeable ModId
+ Language.Clafer.Front.Absclafer: instance Typeable Module
+ Language.Clafer.Front.Absclafer: instance Typeable NCard
+ Language.Clafer.Front.Absclafer: instance Typeable Name
+ Language.Clafer.Front.Absclafer: instance Typeable PosDouble
+ Language.Clafer.Front.Absclafer: instance Typeable PosIdent
+ Language.Clafer.Front.Absclafer: instance Typeable PosInteger
+ Language.Clafer.Front.Absclafer: instance Typeable PosString
+ Language.Clafer.Front.Absclafer: instance Typeable Quant
+ Language.Clafer.Front.Absclafer: instance Typeable SetExp
+ Language.Clafer.Front.Absclafer: instance Typeable SoftConstraint
+ Language.Clafer.Front.Absclafer: instance Typeable Super
+ Language.Clafer.Front.Absclafer: instance Typeable SuperHow
+ Language.Clafer.Front.Absclafer: len :: [a] -> Integer
+ Language.Clafer.Front.ErrM: instance Alternative Err
+ Language.Clafer.Front.ErrM: instance Applicative Err
+ Language.Clafer.Front.ErrM: instance Read a => Read (Err a)
+ Language.Clafer.Front.Lexclafer: AlexAccNone :: AlexAcc a user
+ Language.Clafer.Front.Lexclafer: tokenLineCol :: Token -> (Int, Int)
+ Language.Clafer.Front.Lexclafer: tokenPosn :: Token -> Posn
+ Language.Clafer.Front.Lexclafer: type Byte = Word8
+ Language.Clafer.Front.Lexclafer: utf8Encode :: Char -> [Word8]
+ Language.Clafer.Front.Parclafer: mkCatSpan :: Spannable c => c -> Span
+ Language.Clafer.Front.Parclafer: mkTokenSpan :: Token -> Span
+ Language.Clafer.Intermediate.Analysis: instance Alternative m => Alternative (AnalysisT m)
+ Language.Clafer.Intermediate.ResolverType: instance Applicative TypeAnalysis
- Language.Clafer.Front.Absclafer: Abstract :: Abstract
+ Language.Clafer.Front.Absclafer: Abstract :: Span -> Abstract
- Language.Clafer.Front.Absclafer: AbstractEmpty :: Abstract
+ Language.Clafer.Front.Absclafer: AbstractEmpty :: Span -> Abstract
- Language.Clafer.Front.Absclafer: CardAny :: Card
+ Language.Clafer.Front.Absclafer: CardAny :: Span -> Card
- Language.Clafer.Front.Absclafer: CardEmpty :: Card
+ Language.Clafer.Front.Absclafer: CardEmpty :: Span -> Card
- Language.Clafer.Front.Absclafer: CardInterval :: NCard -> Card
+ Language.Clafer.Front.Absclafer: CardInterval :: Span -> NCard -> Card
- Language.Clafer.Front.Absclafer: CardLone :: Card
+ Language.Clafer.Front.Absclafer: CardLone :: Span -> Card
- Language.Clafer.Front.Absclafer: CardNum :: PosInteger -> Card
+ Language.Clafer.Front.Absclafer: CardNum :: Span -> PosInteger -> Card
- Language.Clafer.Front.Absclafer: CardSome :: Card
+ Language.Clafer.Front.Absclafer: CardSome :: Span -> Card
- Language.Clafer.Front.Absclafer: Clafer :: Abstract -> GCard -> PosIdent -> Super -> Card -> Init -> Elements -> Clafer
+ Language.Clafer.Front.Absclafer: Clafer :: Span -> Abstract -> GCard -> PosIdent -> Super -> Card -> Init -> Elements -> Clafer
- Language.Clafer.Front.Absclafer: ClaferId :: Name -> SetExp
+ Language.Clafer.Front.Absclafer: ClaferId :: Span -> Name -> SetExp
- Language.Clafer.Front.Absclafer: ClaferUse :: Name -> Card -> Elements -> Element
+ Language.Clafer.Front.Absclafer: ClaferUse :: Span -> Name -> Card -> Elements -> Element
- Language.Clafer.Front.Absclafer: Constraint :: [Exp] -> Constraint
+ Language.Clafer.Front.Absclafer: Constraint :: Span -> [Exp] -> Constraint
- Language.Clafer.Front.Absclafer: Decl :: [LocId] -> SetExp -> Decl
+ Language.Clafer.Front.Absclafer: Decl :: Span -> [LocId] -> SetExp -> Decl
- Language.Clafer.Front.Absclafer: DeclAll :: Decl -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: DeclAll :: Span -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: DeclAllDisj :: Decl -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: DeclAllDisj :: Span -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: DeclQuant :: Quant -> Decl -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: DeclQuant :: Span -> Quant -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: DeclQuantDisj :: Quant -> Decl -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: DeclQuantDisj :: Span -> Quant -> Decl -> Exp -> Exp
- Language.Clafer.Front.Absclafer: Difference :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: Difference :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: Domain :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: Domain :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: EAdd :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EAdd :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EAnd :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EAnd :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ECSetExp :: Exp -> Exp
+ Language.Clafer.Front.Absclafer: ECSetExp :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EDiv :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EDiv :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EDouble :: PosDouble -> Exp
+ Language.Clafer.Front.Absclafer: EDouble :: Span -> PosDouble -> Exp
- Language.Clafer.Front.Absclafer: EEq :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EEq :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EGMax :: Exp -> Exp
+ Language.Clafer.Front.Absclafer: EGMax :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EGMin :: Exp -> Exp
+ Language.Clafer.Front.Absclafer: EGMin :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EGt :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EGt :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EGte :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EGte :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EIff :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EIff :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EImplies :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EImplies :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EImpliesElse :: Exp -> Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EImpliesElse :: Span -> Exp -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EIn :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EIn :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EInt :: PosInteger -> Exp
+ Language.Clafer.Front.Absclafer: EInt :: Span -> PosInteger -> Exp
- Language.Clafer.Front.Absclafer: ELt :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: ELt :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ELte :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: ELte :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EMinExp :: Exp -> Exp
+ Language.Clafer.Front.Absclafer: EMinExp :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EMul :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EMul :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ENeg :: Exp -> Exp
+ Language.Clafer.Front.Absclafer: ENeg :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ENeq :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: ENeq :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ENin :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: ENin :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EOr :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EOr :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ESetExp :: SetExp -> Exp
+ Language.Clafer.Front.Absclafer: ESetExp :: Span -> SetExp -> Exp
- Language.Clafer.Front.Absclafer: EStr :: PosString -> Exp
+ Language.Clafer.Front.Absclafer: EStr :: Span -> PosString -> Exp
- Language.Clafer.Front.Absclafer: ESub :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: ESub :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ESumSetExp :: Exp -> Exp
+ Language.Clafer.Front.Absclafer: ESumSetExp :: Span -> Exp -> Exp
- Language.Clafer.Front.Absclafer: EXor :: Exp -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: EXor :: Span -> Exp -> Exp -> Exp
- Language.Clafer.Front.Absclafer: ElementDecl :: Element -> Declaration
+ Language.Clafer.Front.Absclafer: ElementDecl :: Span -> Element -> Declaration
- Language.Clafer.Front.Absclafer: ElementsEmpty :: Elements
+ Language.Clafer.Front.Absclafer: ElementsEmpty :: Span -> Elements
- Language.Clafer.Front.Absclafer: ElementsList :: [Element] -> Elements
+ Language.Clafer.Front.Absclafer: ElementsList :: Span -> [Element] -> Elements
- Language.Clafer.Front.Absclafer: EnumDecl :: PosIdent -> [EnumId] -> Declaration
+ Language.Clafer.Front.Absclafer: EnumDecl :: Span -> PosIdent -> [EnumId] -> Declaration
- Language.Clafer.Front.Absclafer: EnumIdIdent :: PosIdent -> EnumId
+ Language.Clafer.Front.Absclafer: EnumIdIdent :: Span -> PosIdent -> EnumId
- Language.Clafer.Front.Absclafer: ExIntegerAst :: ExInteger
+ Language.Clafer.Front.Absclafer: ExIntegerAst :: Span -> ExInteger
- Language.Clafer.Front.Absclafer: ExIntegerNum :: PosInteger -> ExInteger
+ Language.Clafer.Front.Absclafer: ExIntegerNum :: Span -> PosInteger -> ExInteger
- Language.Clafer.Front.Absclafer: GCardEmpty :: GCard
+ Language.Clafer.Front.Absclafer: GCardEmpty :: Span -> GCard
- Language.Clafer.Front.Absclafer: GCardInterval :: NCard -> GCard
+ Language.Clafer.Front.Absclafer: GCardInterval :: Span -> NCard -> GCard
- Language.Clafer.Front.Absclafer: GCardMux :: GCard
+ Language.Clafer.Front.Absclafer: GCardMux :: Span -> GCard
- Language.Clafer.Front.Absclafer: GCardOpt :: GCard
+ Language.Clafer.Front.Absclafer: GCardOpt :: Span -> GCard
- Language.Clafer.Front.Absclafer: GCardOr :: GCard
+ Language.Clafer.Front.Absclafer: GCardOr :: Span -> GCard
- Language.Clafer.Front.Absclafer: GCardXor :: GCard
+ Language.Clafer.Front.Absclafer: GCardXor :: Span -> GCard
- Language.Clafer.Front.Absclafer: Goal :: [Exp] -> Goal
+ Language.Clafer.Front.Absclafer: Goal :: Span -> [Exp] -> Goal
- Language.Clafer.Front.Absclafer: InitEmpty :: Init
+ Language.Clafer.Front.Absclafer: InitEmpty :: Span -> Init
- Language.Clafer.Front.Absclafer: InitHow_1 :: InitHow
+ Language.Clafer.Front.Absclafer: InitHow_1 :: Span -> InitHow
- Language.Clafer.Front.Absclafer: InitHow_2 :: InitHow
+ Language.Clafer.Front.Absclafer: InitHow_2 :: Span -> InitHow
- Language.Clafer.Front.Absclafer: InitSome :: InitHow -> Exp -> Init
+ Language.Clafer.Front.Absclafer: InitSome :: Span -> InitHow -> Exp -> Init
- Language.Clafer.Front.Absclafer: Intersection :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: Intersection :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: Join :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: Join :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: LocIdIdent :: PosIdent -> LocId
+ Language.Clafer.Front.Absclafer: LocIdIdent :: Span -> PosIdent -> LocId
- Language.Clafer.Front.Absclafer: ModIdIdent :: PosIdent -> ModId
+ Language.Clafer.Front.Absclafer: ModIdIdent :: Span -> PosIdent -> ModId
- Language.Clafer.Front.Absclafer: Module :: [Declaration] -> Module
+ Language.Clafer.Front.Absclafer: Module :: Span -> [Declaration] -> Module
- Language.Clafer.Front.Absclafer: NCard :: PosInteger -> ExInteger -> NCard
+ Language.Clafer.Front.Absclafer: NCard :: Span -> PosInteger -> ExInteger -> NCard
- Language.Clafer.Front.Absclafer: Path :: [ModId] -> Name
+ Language.Clafer.Front.Absclafer: Path :: Span -> [ModId] -> Name
- Language.Clafer.Front.Absclafer: QuantExp :: Quant -> Exp -> Exp
+ Language.Clafer.Front.Absclafer: QuantExp :: Span -> Quant -> Exp -> Exp
- Language.Clafer.Front.Absclafer: QuantLone :: Quant
+ Language.Clafer.Front.Absclafer: QuantLone :: Span -> Quant
- Language.Clafer.Front.Absclafer: QuantNo :: Quant
+ Language.Clafer.Front.Absclafer: QuantNo :: Span -> Quant
- Language.Clafer.Front.Absclafer: QuantOne :: Quant
+ Language.Clafer.Front.Absclafer: QuantOne :: Span -> Quant
- Language.Clafer.Front.Absclafer: QuantSome :: Quant
+ Language.Clafer.Front.Absclafer: QuantSome :: Span -> Quant
- Language.Clafer.Front.Absclafer: Range :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: Range :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: SoftConstraint :: [Exp] -> SoftConstraint
+ Language.Clafer.Front.Absclafer: SoftConstraint :: Span -> [Exp] -> SoftConstraint
- Language.Clafer.Front.Absclafer: Subclafer :: Clafer -> Element
+ Language.Clafer.Front.Absclafer: Subclafer :: Span -> Clafer -> Element
- Language.Clafer.Front.Absclafer: Subconstraint :: Constraint -> Element
+ Language.Clafer.Front.Absclafer: Subconstraint :: Span -> Constraint -> Element
- Language.Clafer.Front.Absclafer: Subgoal :: Goal -> Element
+ Language.Clafer.Front.Absclafer: Subgoal :: Span -> Goal -> Element
- Language.Clafer.Front.Absclafer: Subsoftconstraint :: SoftConstraint -> Element
+ Language.Clafer.Front.Absclafer: Subsoftconstraint :: Span -> SoftConstraint -> Element
- Language.Clafer.Front.Absclafer: SuperArrow :: SuperHow
+ Language.Clafer.Front.Absclafer: SuperArrow :: Span -> SuperHow
- Language.Clafer.Front.Absclafer: SuperColon :: SuperHow
+ Language.Clafer.Front.Absclafer: SuperColon :: Span -> SuperHow
- Language.Clafer.Front.Absclafer: SuperEmpty :: Super
+ Language.Clafer.Front.Absclafer: SuperEmpty :: Span -> Super
- Language.Clafer.Front.Absclafer: SuperMArrow :: SuperHow
+ Language.Clafer.Front.Absclafer: SuperMArrow :: Span -> SuperHow
- Language.Clafer.Front.Absclafer: SuperSome :: SuperHow -> SetExp -> Super
+ Language.Clafer.Front.Absclafer: SuperSome :: Span -> SuperHow -> SetExp -> Super
- Language.Clafer.Front.Absclafer: Union :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: Union :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.Absclafer: UnionCom :: SetExp -> SetExp -> SetExp
+ Language.Clafer.Front.Absclafer: UnionCom :: Span -> SetExp -> SetExp -> SetExp
- Language.Clafer.Front.LayoutResolver: tokenLookup :: String -> Int
+ Language.Clafer.Front.LayoutResolver: tokenLookup :: String -> Maybe Int
- Language.Clafer.Front.Lexclafer: alexGetByte :: AlexInput -> Maybe (Int, AlexInput)
+ Language.Clafer.Front.Lexclafer: alexGetByte :: AlexInput -> Maybe (Byte, AlexInput)
- Language.Clafer.Front.Lexclafer: alexScan :: AlexInput -> Int -> AlexReturn (Posn -> String -> Token)
+ Language.Clafer.Front.Lexclafer: alexScan :: (Posn, Char, [Byte], String) -> Int -> AlexReturn (Posn -> String -> Token)
- Language.Clafer.Front.Lexclafer: alexScanUser :: Any * -> (Posn, Char, String) -> Int -> AlexReturn (Posn -> String -> Token)
+ Language.Clafer.Front.Lexclafer: alexScanUser :: t -> (Posn, Char, [Byte], String) -> Int -> AlexReturn (Posn -> String -> Token)
- Language.Clafer.Front.Lexclafer: alex_accept :: Array Int [AlexAcc (Posn -> String -> Token) user]
+ Language.Clafer.Front.Lexclafer: alex_accept :: Array Int (AlexAcc (Posn -> String -> Token) user)
- Language.Clafer.Front.Lexclafer: alex_scan_tkn :: Any * -> (Posn, Char, String) -> Int# -> (Posn, Char, String) -> Int# -> AlexLastAcc (Posn -> String -> Token) -> (AlexLastAcc (Posn -> String -> Token), (Posn, Char, String))
+ Language.Clafer.Front.Lexclafer: alex_scan_tkn :: t -> t1 -> Int# -> (Posn, Char, [Byte], String) -> Int# -> AlexLastAcc (Posn -> String -> Token) -> (AlexLastAcc (Posn -> String -> Token), (Posn, Char, [Byte], String))
- Language.Clafer.Front.Lexclafer: quickIndex :: Array Int [AlexAcc (Posn -> String -> Token) (Any *)] -> Int -> [AlexAcc (Posn -> String -> Token) (Any *)]
+ Language.Clafer.Front.Lexclafer: quickIndex :: Array Int (AlexAcc (Posn -> String -> Token) (Any *)) -> Int -> AlexAcc (Posn -> String -> Token) (Any *)
- Language.Clafer.Front.Lexclafer: tokenPos :: [Token] -> String
+ Language.Clafer.Front.Lexclafer: tokenPos :: [Token] -> [Char]
- Language.Clafer.Front.Lexclafer: type AlexInput = (Posn, Char, String)
+ Language.Clafer.Front.Lexclafer: type AlexInput = (Posn, Char, [Byte], String)
- Language.Clafer.Front.Parclafer: happyIn10 :: (Declaration) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn10 :: (Clafer) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn11 :: (Clafer) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn11 :: (Constraint) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn12 :: (Constraint) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn12 :: (SoftConstraint) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn13 :: (SoftConstraint) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn13 :: (Goal) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn14 :: (Goal) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn14 :: (Abstract) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn15 :: (Abstract) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn15 :: (Elements) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn16 :: (Elements) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn16 :: (Element) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn17 :: (Element) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn17 :: (Super) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn18 :: (Super) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn18 :: (SuperHow) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn19 :: (SuperHow) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn19 :: (Init) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn20 :: (Init) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn20 :: (InitHow) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn21 :: (InitHow) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn21 :: (GCard) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn22 :: (GCard) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn22 :: (Card) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn23 :: (Card) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn23 :: (NCard) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn24 :: (NCard) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn24 :: (ExInteger) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn25 :: (ExInteger) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn25 :: (Name) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn26 :: (Name) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn26 :: (Exp) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn4 :: (Integer) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn4 :: (PosInteger) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn40 :: (Exp) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn40 :: (SetExp) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn47 :: (SetExp) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn47 :: (Decl) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn48 :: (Decl) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn48 :: (Quant) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn49 :: (Quant) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn49 :: (EnumId) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn5 :: (PosInteger) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn5 :: (PosDouble) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn50 :: (EnumId) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn50 :: (ModId) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn51 :: (ModId) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn51 :: (LocId) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn52 :: (LocId) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn52 :: ([Declaration]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn53 :: (Pos) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn53 :: ([EnumId]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn54 :: (Span) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn54 :: ([Element]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn55 :: ([Declaration]) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn55 :: ([Exp]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn56 :: ([EnumId]) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn56 :: ([LocId]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn57 :: ([Element]) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn57 :: ([ModId]) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn6 :: (PosDouble) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn6 :: (PosString) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn7 :: (PosString) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn7 :: (PosIdent) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn8 :: (PosIdent) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn8 :: (Module) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyIn9 :: (Module) -> (HappyAbsSyn)
+ Language.Clafer.Front.Parclafer: happyIn9 :: (Declaration) -> (HappyAbsSyn)
- Language.Clafer.Front.Parclafer: happyOut10 :: (HappyAbsSyn) -> (Declaration)
+ Language.Clafer.Front.Parclafer: happyOut10 :: (HappyAbsSyn) -> (Clafer)
- Language.Clafer.Front.Parclafer: happyOut11 :: (HappyAbsSyn) -> (Clafer)
+ Language.Clafer.Front.Parclafer: happyOut11 :: (HappyAbsSyn) -> (Constraint)
- Language.Clafer.Front.Parclafer: happyOut12 :: (HappyAbsSyn) -> (Constraint)
+ Language.Clafer.Front.Parclafer: happyOut12 :: (HappyAbsSyn) -> (SoftConstraint)
- Language.Clafer.Front.Parclafer: happyOut13 :: (HappyAbsSyn) -> (SoftConstraint)
+ Language.Clafer.Front.Parclafer: happyOut13 :: (HappyAbsSyn) -> (Goal)
- Language.Clafer.Front.Parclafer: happyOut14 :: (HappyAbsSyn) -> (Goal)
+ Language.Clafer.Front.Parclafer: happyOut14 :: (HappyAbsSyn) -> (Abstract)
- Language.Clafer.Front.Parclafer: happyOut15 :: (HappyAbsSyn) -> (Abstract)
+ Language.Clafer.Front.Parclafer: happyOut15 :: (HappyAbsSyn) -> (Elements)
- Language.Clafer.Front.Parclafer: happyOut16 :: (HappyAbsSyn) -> (Elements)
+ Language.Clafer.Front.Parclafer: happyOut16 :: (HappyAbsSyn) -> (Element)
- Language.Clafer.Front.Parclafer: happyOut17 :: (HappyAbsSyn) -> (Element)
+ Language.Clafer.Front.Parclafer: happyOut17 :: (HappyAbsSyn) -> (Super)
- Language.Clafer.Front.Parclafer: happyOut18 :: (HappyAbsSyn) -> (Super)
+ Language.Clafer.Front.Parclafer: happyOut18 :: (HappyAbsSyn) -> (SuperHow)
- Language.Clafer.Front.Parclafer: happyOut19 :: (HappyAbsSyn) -> (SuperHow)
+ Language.Clafer.Front.Parclafer: happyOut19 :: (HappyAbsSyn) -> (Init)
- Language.Clafer.Front.Parclafer: happyOut20 :: (HappyAbsSyn) -> (Init)
+ Language.Clafer.Front.Parclafer: happyOut20 :: (HappyAbsSyn) -> (InitHow)
- Language.Clafer.Front.Parclafer: happyOut21 :: (HappyAbsSyn) -> (InitHow)
+ Language.Clafer.Front.Parclafer: happyOut21 :: (HappyAbsSyn) -> (GCard)
- Language.Clafer.Front.Parclafer: happyOut22 :: (HappyAbsSyn) -> (GCard)
+ Language.Clafer.Front.Parclafer: happyOut22 :: (HappyAbsSyn) -> (Card)
- Language.Clafer.Front.Parclafer: happyOut23 :: (HappyAbsSyn) -> (Card)
+ Language.Clafer.Front.Parclafer: happyOut23 :: (HappyAbsSyn) -> (NCard)
- Language.Clafer.Front.Parclafer: happyOut24 :: (HappyAbsSyn) -> (NCard)
+ Language.Clafer.Front.Parclafer: happyOut24 :: (HappyAbsSyn) -> (ExInteger)
- Language.Clafer.Front.Parclafer: happyOut25 :: (HappyAbsSyn) -> (ExInteger)
+ Language.Clafer.Front.Parclafer: happyOut25 :: (HappyAbsSyn) -> (Name)
- Language.Clafer.Front.Parclafer: happyOut26 :: (HappyAbsSyn) -> (Name)
+ Language.Clafer.Front.Parclafer: happyOut26 :: (HappyAbsSyn) -> (Exp)
- Language.Clafer.Front.Parclafer: happyOut4 :: (HappyAbsSyn) -> (Integer)
+ Language.Clafer.Front.Parclafer: happyOut4 :: (HappyAbsSyn) -> (PosInteger)
- Language.Clafer.Front.Parclafer: happyOut40 :: (HappyAbsSyn) -> (Exp)
+ Language.Clafer.Front.Parclafer: happyOut40 :: (HappyAbsSyn) -> (SetExp)
- Language.Clafer.Front.Parclafer: happyOut47 :: (HappyAbsSyn) -> (SetExp)
+ Language.Clafer.Front.Parclafer: happyOut47 :: (HappyAbsSyn) -> (Decl)
- Language.Clafer.Front.Parclafer: happyOut48 :: (HappyAbsSyn) -> (Decl)
+ Language.Clafer.Front.Parclafer: happyOut48 :: (HappyAbsSyn) -> (Quant)
- Language.Clafer.Front.Parclafer: happyOut49 :: (HappyAbsSyn) -> (Quant)
+ Language.Clafer.Front.Parclafer: happyOut49 :: (HappyAbsSyn) -> (EnumId)
- Language.Clafer.Front.Parclafer: happyOut5 :: (HappyAbsSyn) -> (PosInteger)
+ Language.Clafer.Front.Parclafer: happyOut5 :: (HappyAbsSyn) -> (PosDouble)
- Language.Clafer.Front.Parclafer: happyOut50 :: (HappyAbsSyn) -> (EnumId)
+ Language.Clafer.Front.Parclafer: happyOut50 :: (HappyAbsSyn) -> (ModId)
- Language.Clafer.Front.Parclafer: happyOut51 :: (HappyAbsSyn) -> (ModId)
+ Language.Clafer.Front.Parclafer: happyOut51 :: (HappyAbsSyn) -> (LocId)
- Language.Clafer.Front.Parclafer: happyOut52 :: (HappyAbsSyn) -> (LocId)
+ Language.Clafer.Front.Parclafer: happyOut52 :: (HappyAbsSyn) -> ([Declaration])
- Language.Clafer.Front.Parclafer: happyOut53 :: (HappyAbsSyn) -> (Pos)
+ Language.Clafer.Front.Parclafer: happyOut53 :: (HappyAbsSyn) -> ([EnumId])
- Language.Clafer.Front.Parclafer: happyOut54 :: (HappyAbsSyn) -> (Span)
+ Language.Clafer.Front.Parclafer: happyOut54 :: (HappyAbsSyn) -> ([Element])
- Language.Clafer.Front.Parclafer: happyOut55 :: (HappyAbsSyn) -> ([Declaration])
+ Language.Clafer.Front.Parclafer: happyOut55 :: (HappyAbsSyn) -> ([Exp])
- Language.Clafer.Front.Parclafer: happyOut56 :: (HappyAbsSyn) -> ([EnumId])
+ Language.Clafer.Front.Parclafer: happyOut56 :: (HappyAbsSyn) -> ([LocId])
- Language.Clafer.Front.Parclafer: happyOut57 :: (HappyAbsSyn) -> ([Element])
+ Language.Clafer.Front.Parclafer: happyOut57 :: (HappyAbsSyn) -> ([ModId])
- Language.Clafer.Front.Parclafer: happyOut6 :: (HappyAbsSyn) -> (PosDouble)
+ Language.Clafer.Front.Parclafer: happyOut6 :: (HappyAbsSyn) -> (PosString)
- Language.Clafer.Front.Parclafer: happyOut7 :: (HappyAbsSyn) -> (PosString)
+ Language.Clafer.Front.Parclafer: happyOut7 :: (HappyAbsSyn) -> (PosIdent)
- Language.Clafer.Front.Parclafer: happyOut8 :: (HappyAbsSyn) -> (PosIdent)
+ Language.Clafer.Front.Parclafer: happyOut8 :: (HappyAbsSyn) -> (Module)
- Language.Clafer.Front.Parclafer: happyOut9 :: (HappyAbsSyn) -> (Module)
+ Language.Clafer.Front.Parclafer: happyOut9 :: (HappyAbsSyn) -> (Declaration)
- Language.Clafer.Front.Parclafer: happyReduction_10 :: t -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_10 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_100 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_100 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_101 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_101 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_102 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_102 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_103 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_103 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_104 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_104 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_105 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_105 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_107 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_107 :: t -> HappyAbsSyn -> t1 -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_108 :: t -> HappyAbsSyn -> t1 -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_108 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_109 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_109 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_11 :: t -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_11 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_117 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_117 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_119 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_119 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_12 :: t -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_12 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_120 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_120 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_121 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_121 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_122 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_122 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_125 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_125 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_126 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_126 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_13 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_13 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_14 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_14 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_15 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_15 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_16 :: t -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_16 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_17 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_17 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_18 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_18 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_21 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_21 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_22 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_22 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_23 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_23 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_26 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_26 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_27 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_27 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_28 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_28 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_30 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_30 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_31 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_31 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_36 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_36 :: HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_37 :: HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_37 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_42 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_42 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_43 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_43 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_46 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_46 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_50 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_50 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_51 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_51 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_53 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_53 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_54 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_54 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_55 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_55 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_56 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_56 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_57 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_57 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_58 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_58 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_59 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_59 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_6 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_6 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_60 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_60 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_61 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_61 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_62 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_62 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_63 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_63 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_64 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_64 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_65 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_65 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_66 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_66 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_67 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_67 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_68 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_68 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_69 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_69 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_7 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_7 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_70 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_70 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_71 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_71 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_72 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_72 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_73 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_73 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_74 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_74 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_75 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_75 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_76 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_76 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_77 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_77 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_78 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_78 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_79 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_79 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_8 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_8 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_80 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_80 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_81 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_81 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_82 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_82 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_85 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_85 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_86 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_86 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_87 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_87 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_9 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_9 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_92 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_92 :: t -> HappyAbsSyn -> t1 -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_93 :: t -> HappyAbsSyn -> t1 -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_93 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_94 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_94 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_95 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_95 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_96 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_96 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_97 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_97 :: HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_98 :: HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_98 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
- Language.Clafer.Front.Parclafer: happyReduction_99 :: HappyAbsSyn -> t -> HappyAbsSyn -> HappyAbsSyn
+ Language.Clafer.Front.Parclafer: happyReduction_99 :: HappyAbsSyn -> HappyAbsSyn

Files

CHANGES.md view
@@ -1,3 +1,7 @@+**Clafer Version 0.3.7 released on Oct 23, 2014**
+
+[Release](https://github.com/gsdlab/clafer/pull/53)
+
 **Clafer Version 0.3.6.1 released on Jul 08, 2014**
 
 [Release](https://github.com/gsdlab/clafer/pull/50)
− IDEs/clafer-README.md
@@ -1,20 +0,0 @@-IDE Integrations
-================
-
-Sublime Text 2
---------------
-
-We provide a build system configuration. 
-
-### Usage
-
-Use `<CTRL>+B` to compile a Clafer `.cfr` file. 
-This build system assumes that Clafer executable is in system `PATH` and is automatically selected for files with extension `.cfr`.
-
-### Installation 
-
-1. Copy the folder `User` from `IDEs\sublime-text-2\Packages` to the folder `Packages` in Sublime Text 2 folder inside your home directory.
-
-> Note: 
-> on Windows 7 and 8, the folder is `<user name>\AppData\Roaming\Sublime Text 2\Packages`.
-> on Mac, the folder is `~/Library/Application Support/Sublime Text 2/Packages`
− IDEs/sublime-text-2/Packages/User/clafer.sublime-build
@@ -1,4 +0,0 @@-{
-	"cmd": [ "clafer.exe", "$file" ],
-	"selector": "cfr"
-}
Makefile view
@@ -15,7 +15,7 @@ 
 init:
 	cabal sandbox init --sandbox=../.clafertools-cabal-sandbox
-	cabal install --only-dependencies $(GPLK_LIBS_INCLUDES) $(MAC_USR_LIB)
+	cabal install --only-dependencies $(GPLK_LIBS_INCLUDES) $(MAC_USR_LIB) --enable-tests
 
 build: 
 	$(MAKE) -C $(TOOL_DIR)
@@ -32,17 +32,20 @@ 	cp -f tools/alloy4.2.jar $(to)/tools
 	cp -f tools/XsdCheck.class $(to)/tools
 	cp -f tools/ecore2clafer.jar $(to)/tools
-	cp -f -R IDEs $(to)/
-	if test "$(glpk)" ; then cp -f $(glpk)/w32/glpk_4_52.dll $(to); fi
+	if test "$(glpk)" ; then cp -f $(glpk)/w32/glpk_4_55.dll $(to); fi
 	cabal install --bindir=$(to) $(GPLK_LIBS_INCLUDES) $(MAC_USR_LIB) --ghc-option="-O"
 
 # Removes current build and makes a clean new one (Don't use if starting from scratch!)
 cleanEnv:
 	make clean
-	ghc-pkg unregister clafer
+	ghc-pkg unregister clafer --package-db=../.clafertools-cabal-sandbox/x86_64-windows-ghc-7.8.3
 	rm `which clafer`
 	make 
 
+# regenerate grammar, call after clafer.cf changed
+grammar:
+	$(MAKE) -C $(SRC_DIR) grammar
+
 # build Schema.hs from ClaferIG.xsd, call after .xsd changed
 Schema.hs:
 	$(MAKE) -C $(SRC_DIR) Schema.hs
@@ -66,17 +69,8 @@ 	cabal test	
 	$(MAKE) -C $(TEST_DIR) test
 
-validateAlloy:
-	$(MAKE) -C $(TEST_DIR) validateAlloy
-
-validateXML:	
-	$(MAKE) -C $(TEST_DIR) validateXML
-
-validateClafer:
-#	$(MAKE) -C $(TEST_DIR) validateClafer
-
-generatePython:
-	$(MAKE) -C $(TEST_DIR) generatePython
+generateAlloyJSPythonXMLXHTMLDot:
+	$(MAKE) -C $(TEST_DIR) generateAlloyJSPythonXMLXHTMLDot
 
 diffRegressions:
 	$(MAKE) -C $(TEST_DIR) diffRegressions
@@ -86,12 +80,9 @@ 
 clean:
 	rm -f clafer
-	rm -rf dist
+	cabal clean
 	$(MAKE) -C $(SRC_DIR) clean
 	$(MAKE) -C $(TOOL_DIR) clean
-	find . -type f -name '*.o' -print0 | xargs -0 rm -f
-	find . -type f -name '*.hi' -print0 | xargs -0 rm -f
-	find . -type f -name '*~' -print0 | xargs -0 rm -f
 	$(MAKE) cleanTest
 
 cleanTest:
README.md view
@@ -1,7 +1,7 @@ Clafer
 ======
 
-v0.3.6.1
+v0.3.7
 
 [Clafer](http://clafer.org) is a general-purpose lightweight structural modeling language developed by 
 [GSD Lab](http://gsd.uwaterloo.ca/), [University of Waterloo](http://uwaterloo.ca), and 
@@ -24,16 +24,15 @@ ===============
 
 Clafer compiler provides a reference language implementation. 
-It translates models in Clafer to other formats (e.g. Alloy, XML, Python, JS, HTML, DOT) to allow for reasoning and processing with existing tools (Alloy Analyzer, Choco3, and Z3 SMT solver).
+It translates models in Clafer to other formats (e.g., Alloy, XML, Python, JS, HTML, DOT) to allow for reasoning and processing with existing tools (Alloy Analyzer, Choco3, and Z3 SMT solver).
 
 Currently, the compiler is used by 
 
 * Backends
   * Alloy-based Instance Generator ([ClaferIG](https://github.com/gsdlab/claferIG)), 
-  * Alloy-based Multi-Objective Optimizer ([ClaferMOO](https://github.com/gsdlab/ClaferMooStandalone)),
-  * Choco3-based Instance Generator and Multi-Objective Optimizer ([ChocoIG](https://github.com/gsdlab/claferIG)), and
-  * Z3-based Instance Generator and Multi-Objective Optimizer ([ClaferZ3](https://github.com/gsdlab/claferIG)), 
-* Frontends
+  * Choco3-based Instance Generator and Multi-Objective Optimizer ([chocosolver](https://github.com/gsdlab/chocosolver), [ClaferChocoIG](https://github.com/gsdlab/ClaferChocoIG)), and
+  * Z3-based Instance Generator and Multi-Objective Optimizer ([ClaferSMT](https://github.com/gsdlab/claferSMT)), 
+* Web Frontends
   * Clafer Integrated Development Environment ([ClaferIDE](https://github.com/gsdlab/claferIDE)),
   * Clafer Configurator ([ClaferConfigurator](https://github.com/gsdlab/ClaferConfigurator)), 
   * Multi-Objective [Visualizer and Explorer](https://github.com/gsdlab/ClaferMooVisualizer), and 
@@ -47,6 +46,7 @@ * [Michał Antkiewicz](http://gsd.uwaterloo.ca/mantkiew), Requirements, development, architecture, testing, technology transfer.
 * [Ed Zulkoski](http://gsd.uwaterloo.ca/ezulkosk), Python IR Generator.
 * Luke Michael Brown, co-op student May-Aug 2013. Many improvements.
+* Paulius Juodisius, [customized BNFC generator](https://github.com/juodaspaulius/bnfc) and layout resolver.
 * [Rafael Olaechea](http://gsd.uwaterloo.ca/rolaechea), Multi-Objective Optimization extensions.
 
 Getting the Clafer Compiler
@@ -60,7 +60,8 @@ 
 Required:
 
-* [GNU Linear Programming Kit](http://www.gnu.org/software/glpk/) v4.52
+* [GNU Linear Programming Kit](http://www.gnu.org/software/glpk/) v4.55
+  * On Windows, [WinGLPK](http://winglpk.sourceforge.net/)
 
 Optional:
 
@@ -75,26 +76,26 @@ 
 On Linux
 
-1. [libglpk-dev](http://www.gnu.org/software/glpk/) v4.52
+1. [libglpk-dev](http://www.gnu.org/software/glpk/) v4.55
   * execute `sudo apt-get install libglpk-dev` on Ubuntu
 2. [libgmp-dev](http://gmplib.org/)
   * execute `sudo apt-get install libgmp-dev` on Ubuntu
 
 On Windows
 
-1. The binary distribution already includes the GNU Linear Programming Kit DLL `glpk_4_52.dll`.
-2. Install [WinGLPK](http://winglpk.sourceforge.net/) v4.52
-  * inside the `w32` folder, copy `glpk_4_52.dll` to `glpk.dll` so that it can be found when building Haskell package `glpk-hs`
-  * from `w32` folder, copy `glpk_4_52.dll` to `<user>\AppData\Roaming\cabal\bin`
+1. The binary distribution already includes the GNU Linear Programming Kit DLL `glpk_4_55.dll`.
+2. Install [WinGLPK](http://winglpk.sourceforge.net/) v4.55
+  * inside the `w64` folder, copy `glpk_4_55.dll` to `glpk.dll` so that it can be found when building Haskell package `glpk-hs`
+  * from `w64` folder, copy `glpk_4_55.dll` to `<user>\AppData\Roaming\cabal\bin`
 
 On Mac
 
-1. install GPLK 4.52 from [MacPorts](http://www.macports.org/)
+1. install GPLK 4.55 from [MacPorts](http://www.macports.org/)
   * execute `sudo port install glpk +universal`
 
 ### Installation from binaries
 
-Binary distributions of the release 0.3.6.1 of Clafer Tools for Windows, Mac, and Linux, 
+Binary distributions of the release 0.3.7 of Clafer Tools for Windows, Mac, and Linux, 
 can be downloaded from 
 [Clafer Tools - Binary Distributions](http://http://gsd.uwaterloo.ca/clafer-tools-binary-distributions). 
 
@@ -105,25 +106,27 @@ 
 Dependencies
 
-* [The Haskell Platform](http://hackage.haskell.org/platform/) v2013.2.0.0
+* [The Haskell Platform](http://hackage.haskell.org/platform/) v2014.2.0.0 64bit
+  * on Windows, use 32bit
 
-Clafer is now available on [Hackage](http://hackage.haskell.org/package/clafer-0.3.6.1/) and it can be installed using
+Clafer is now available on [Hackage](http://hackage.haskell.org/package/clafer-0.3.7/) and it can be installed using
 
 1. `cabal update`
 2. `cabal install clafer`
-3. `cd <cabal's lib or share folder>`  (`C:\Users\<user>\AppData\Roaming\cabal\i386-windows-ghc-7.6.3\clafer-0.3.6.1` on Windows or `.cabal/share/x86_64-linux-ghc-7.6.3/clafer-0.3.6.1/` on Linux)
+3. `cd <cabal's lib or share folder>`  (`C:\Users\<user>\AppData\Roaming\cabal\x86_64-windows-ghc-7.8.3\clafer-0.3.7` on Windows or `.cabal/share/x86_64-linux-ghc-7.8.3/clafer-0.3.7/` on Linux)
 4. to automatically download Alloy jars
   * execute `make` in `tools` 
 
 On Windows 
 
-* copy GLPK's dll `glpk-0.4.52.dll` to the `C:\Users\<user>\AppData\Roaming\cabal\bin` folder or any other folder on the system `PATH`
+* copy GLPK's dll `glpk_4_55.dll` to the `C:\Users\<user>\AppData\Roaming\cabal\bin` folder or any other folder on the system `PATH`
 
 ### Installation from the source code
 
 Dependencies
 
-* [The Haskell Platform](http://hackage.haskell.org/platform/) v2013.2.0.0
+* [The Haskell Platform](http://hackage.haskell.org/platform/) v2014.2.0.0 64bit
+  * on Windows, use 32bit
   * Cabal >= 1.18
 * [Alloy4.1 and/or Alloy4.2](http://alloy.mit.edu/alloy/download.html)
   * downloaded automatically during the build
@@ -131,12 +134,11 @@ 
 On Windows 
 
-* [MinGW+MSYS](http://mingw.org) 
-  * download [mingw-get-setup.exe](http://sourceforge.net/projects/mingw/files/Installer/mingw-get/)
-  * since the Haskell Platform already contains MinGW, only install MSYS. Installing another MinGW causes problems as it contains different versions of tools as compared to the MinGW in the Haskell Platform
-  * choose the existing MinGW location, e.g., `c:\...\HaskellPlatform\2013.2.0.0\MinGw`
-  * ensure `wget` and `unzip` are selected to be installed 
-  * add the `bin` folder of MSYS (`MinGW\MSYS\1.0\bin`) to your system path
+* [MSYS2](http://msys2.sourceforge.net/) 
+  * download MSYS2 installer
+  * in MSYS2 console, execute
+     * `pacman -Syu` 
+     * `pacman -S make wget unzip diffutils`
 
 #### Important: Branches must correspond
 
@@ -149,7 +151,7 @@ #### Building
 
 1. install the dependencies
-2. open the command line terminal. On Windows, open MinGW.
+2. open the command line terminal. On Windows, open MSYS2 terminal.
 3. in some `<source directory>` of your choice, execute 
   * `git clone git://github.com/gsdlab/clafer.git`
 4. in `<source directory>/clafer`, execute
@@ -157,25 +159,29 @@ 5. On Linux and Mac execute 
   * `make init`
   * `make`
-6. On Windows (in MinGW), execute 
+6. On Windows (in MSYS2 console), execute 
   * `make glpk=/c/<your WinGLPK install dir>`
 
 ### Installation
 
 1. On Linux and Mac execute 
   * `make install to=<target directory>` 
-2. On Windows (in MinGW), execute 
+2. On Windows (in MSYS2 console), execute 
   * `make glpk=/c/<your WinGLPK instal dir> to=/c/Users/<your user name>/AppData/Roaming/cabal/bin`
 
 #### Note: 
 > On Windows, use `/` with the `make` command instead of `\`.
 
-Integration with Sublime Text 2
--------------------------------
+Integration with Sublime Text 2/3
+---------------------------------
 
-See [IDEs/clafer-README.md](IDEs/clafer-README.md)
+See [ClaferToolsST](https://github.com/gsdlab/ClaferToolsST)
 
+Integration with VIM
+--------------------
 
+See [clafer-vim](https://github.com/wasowski/clafer-vim)
+
 Usage
 =====
 
@@ -185,14 +191,14 @@ (As printed by `clafer --help`)
 
 ```
-Clafer 0.3.6.1
+Clafer 0.3.7
 
 clafer [OPTIONS] [FILE]
 
 Common flags:
   -m --mode=CLAFERMODE                    Generated output type. Available
-                                          CLAFERMODEs are: 'alloy' (default,
-                                          Alloy 4.1); 'alloy42' (Alloy 4.2);
+                                          CLAFERMODEs are: 'alloy' (Alloy 4.1);
+                                          'alloy42' (default, Alloy 4.2);
                                           'xml' (intermediate representation of
                                           Clafer model); 'clafer' (analyzed and
                                           desugared clafer model); 'html'
@@ -275,7 +281,7 @@ 
 `clafer model.cfr -m alloy -m xml -m html -m graph --self-contained --show-references --no-stats`
 
-The mode `-m alloy` is only a default mode if no other modes are given. When other modes are given, the mode `-m alloy` must be added explicitly if needed.
+The mode `-m alloy42` is only a default mode if no other modes are given. When other modes are given, the mode `-m alloy42` must be added explicitly if needed.
 
 Additionally, `[OPTIONS]` can also be specified directly in the model file by inserting the following compiler directive as the first line of the file:
 
@@ -286,7 +292,7 @@ for example
 
 ```
-//# --keep-unused -m=alloy42
+//# --keep-unused -m=alloy
 ```
 
 Options given at command line override the options given in the file using `//#` which, in turn, override the defaults.
@@ -310,7 +316,7 @@ Need help?
 ==========
 * See [language's website](http://clafer.org) for news, technical reports and more
-  * Check out a [Clafer tutorial](http://t3-necsis.cs.uwaterloo.ca:8091/Tutorial/Intro)
+  * Check out a [Learning Clafer section](http://t3-necsis.cs.uwaterloo.ca:8091/#Learning Clafer)
   * Try a live instance of [ClaferWiki](http://t3-necsis.cs.uwaterloo.ca:8091) which contains a repository of models for various applications
   * Try a live instance of [ClaferIDE](http://t3-necsis.cs.uwaterloo.ca:8094)
   * Try a live instance of [ClaferConfigurator](http://t3-necsis.cs.uwaterloo.ca:8093)
clafer.cabal view
@@ -1,12 +1,12 @@ Name:               clafer
-Version:            0.3.6.1
+Version:            0.3.7
 Synopsis:           clafer compiles Clafer models to other formats, such as Alloy, XML, HTML, Dot.
 Description:        Clafer is a general purpose, lightweight, structural modeling language developed at GSD Lab, University of Waterloo. Lightweight modeling aims at improving the understanding of the problem domain in the early stages of software development and determining the requirements with fewer defects. Clafer's goal is to make modeling more accessible to a wider range of users and domains. The tool provides a reference language implementation. It translates models to other formats (e.g. Alloy, XML) to allow for reasoning with existing tools.
 Homepage:           http://clafer.org
 License:            MIT
 License-file:       LICENSE
-Author:             Kacper Bąk, Jimmy Liang, Michał Antkiewicz, Chris Walker, Luke Michael Brown
-Maintainer:         Michał Antkiewicz <mantkiew@gsd.uwaterloo.ca>
+Author:             Kacper Bak, Jimmy Liang, Michal Antkiewicz, Ed Zulkoski, Luke Michael Brown, Paulius Juodisius, Rafael Olaechea
+Maintainer:         Michal Antkiewicz <mantkiew@gsd.uwaterloo.ca>
 Stability:          Experimental
 Category:           Model
 Build-type:         Simple
@@ -14,8 +14,6 @@ data-files:         README.md,
                     CHANGES.md,
                     logo.pdf,
-                    IDEs/clafer-README.md,
-                    IDEs/sublime-text-2/Packages/User/clafer.sublime-build
                     Makefile,
                     tools/XsdCheck.java,
                     tools/XsdCheck.class,
@@ -32,42 +30,22 @@                     DeriveDataTypeable,
                     RankNTypes
     main-is:        clafer.hs
-    build-depends:  array >= 0.4.0.1,
-                    base >= 4.6.0.1 && < 5,
+    hs-source-dirs: src-cmd
+    build-depends:  base >= 4.6.0.1 && < 5,
                     containers >= 0.5.0.0,
-                    directory >= 1.2.0.1,
                     filepath >= 1.3.0.1,
                     process >= 1.1.0.2,
 
-                    HUnit >= 1.2.5.2,
                     mtl >= 2.1.2,
-                    parsec >= 3.1.3,
-                    QuickCheck >= 2.6, 
-                    transformers >= 0.3.0.0,
-
-                    data-stringmap >= 1.0.1.1,
-                    aeson >= 0.7.0.2,
-                    json-builder >= 0.3,
-                    lens >= 4.1.1,
-                    string-conversions >= 0.3.0.2,
                     cmdargs >= 0.10.7, 
-                    executable-path >= 0.0.3, 
-                    glpk-hs >= 0.3.4,
-                    MaybeT >= 0.1.2,
                     split >= 0.2.2, 
-                    test-framework >= 0.8.0.3, 
-                    test-framework-hunit >= 0.3.0.1, 
-                    test-framework-quickcheck2 >= 0.3.0.2,
-                    test-framework-th >= 0.2.4,
-                    text >= 0.11.3.1,
 
-                    clafer == 0.3.6.1
+                    clafer == 0.3.7
     if os(windows)
         build-depends: HaXml == 1.24
     else
         build-depends: HaXml >= 1.24
 
-    hs-source-dirs: src
     other-modules: Paths_clafer
 
 library 
@@ -84,26 +62,20 @@                     filepath >= 1.3.0.1,
                     process >= 1.1.0.2,
 
-                    HUnit >= 1.2.5.2,
                     mtl >= 2.1.2,
                     parsec >= 3.1.3,
-                    QuickCheck >= 2.6, 
                     transformers >= 0.3.0.0,
 
                     data-stringmap >= 1.0.1.1,
-                    aeson >= 0.7.0.2,
+                    aeson >= 0.7.0.6,
                     json-builder >= 0.3,
-                    lens >= 4.1.1,
+                    lens >= 4.1.1 && < 4.4,
                     string-conversions >= 0.3.0.2,
                     cmdargs >= 0.10.7, 
                     executable-path >= 0.0.3, 
                     glpk-hs >= 0.3.4,
                     MaybeT >= 0.1.2,
                     split >= 0.2.2, 
-                    test-framework >= 0.8.0.3, 
-                    test-framework-hunit >= 0.3.0.1, 
-                    test-framework-quickcheck2 >= 0.3.0.2,
-                    test-framework-th >= 0.2.4,
                     text >= 0.11.3.1
 
     if os(windows)
@@ -126,7 +98,6 @@                      Language.Clafer.Front.ErrM,
                      Language.Clafer.Front.LayoutResolver,
                      Language.Clafer.Front.Lexclafer,
-                     Language.Clafer.Front.Mapper,
                      Language.Clafer.Front.Parclafer,
                      Language.Clafer.Front.Printclafer,
                      Language.Clafer.Generator.Alloy,
@@ -161,43 +132,28 @@     main-is:        test-suite.hs
     hs-source-dirs: test
     build-depends:  
-                    array >= 0.4.0.1,
                     base >= 4.6.0.1 && < 5,
                     containers >= 0.5.0.0,
                     directory >= 1.2.0.1,
                     filepath >= 1.3.0.1,
-                    process >= 1.1.0.2,
 
                     HUnit >= 1.2.5.2,
                     mtl >= 2.1.2,
-                    parsec >= 3.1.3,
                     QuickCheck >= 2.6, 
-                    transformers >= 0.3.0.0,
 
-                    data-stringmap >= 1.0.1.1,
-                    aeson >= 0.7.0.2,
-                    json-builder >= 0.3,
-                    lens >= 4.1.1,
-                    string-conversions >= 0.3.0.2,
-                    cmdargs >= 0.10.7, 
-                    executable-path >= 0.0.3, 
-                    glpk-hs >= 0.3.4,
-                    MaybeT >= 0.1.2,
-                    split >= 0.2.2, 
-                    test-framework >= 0.8.0.3, 
-                    test-framework-hunit >= 0.3.0.1, 
-                    test-framework-quickcheck2 >= 0.3.0.2,
-                    test-framework-th >= 0.2.4,
-                    text >= 0.11.3.1,
+                    lens >= 4.1.1 && < 4.4,
+                    tasty >= 0.10,
+                    tasty-hunit >= 0.9,
+                    tasty-th >= 0.1.2,
 
-                    clafer == 0.3.6.1
+                    clafer == 0.3.7
 
     if os(windows)
         build-depends: HaXml == 1.24
     else
         build-depends: HaXml >= 1.24
 
-    ghc-options:    -Wall -fno-warn-unused-do-bind -fno-warn-orphans
+    ghc-options:    -Wall -fno-warn-unused-do-bind -fno-warn-orphans -threaded
 
     other-modules:  Paths_clafer,
                     Functions,
+ dist/build/Language/Clafer/Front/Lexclafer.hs view
@@ -0,0 +1,375 @@+{-# LANGUAGE CPP,MagicHash #-}
+{-# LINE 3 "src\Language\Clafer\Front\Lexclafer.x" #-}
+
+{-# OPTIONS -fno-warn-incomplete-patterns #-}
+{-# OPTIONS_GHC -w #-}
+module Language.Clafer.Front.Lexclafer where
+
+
+
+import qualified Data.Bits
+import Data.Word (Word8)
+
+#if __GLASGOW_HASKELL__ >= 603
+#include "ghcconfig.h"
+#elif defined(__GLASGOW_HASKELL__)
+#include "config.h"
+#endif
+#if __GLASGOW_HASKELL__ >= 503
+import Data.Array
+import Data.Char (ord)
+import Data.Array.Base (unsafeAt)
+#else
+import Array
+import Char (ord)
+#endif
+#if __GLASGOW_HASKELL__ >= 503
+import GHC.Exts
+#else
+import GlaExts
+#endif
+alex_base :: AlexAddr
+alex_base = AlexA# "\xf8\xff\xff\xff\x4c\x00\x00\x00\x22\x01\x00\x00\xa2\x01\x00\x00\x22\x02\x00\x00\x22\x03\x00\x00\x92\x00\x00\x00\x00\x00\x00\x00\x13\x03\x00\x00\x13\x04\x00\x00\x34\x00\x00\x00\xd3\x03\x00\x00\xa9\x04\x00\x00\x00\x00\x00\x00\x15\x04\x00\x00\x29\x05\x00\x00\x9e\x05\x00\x00\xd9\xff\xff\xff\x4d\x00\x00\x00\x61\x00\x00\x00\x9e\x06\x00\x00\x5e\x06\x00\x00\x00\x00\x00\x00\x54\x07\x00\x00\x00\x00\x00\x00\x2a\x08\x00\x00\x7e\x00\x00\x00\xed\xff\xff\xff\xdc\xff\xff\xff\x4f\x00\x00\x00\xcb\xff\xff\xff\xd6\xff\xff\xff\x00\x00\x00\x00\x99\xff\xff\xff\xd8\xff\xff\xff\x3d\x00\x00\x00\xef\xff\xff\xff\xf9\xff\xff\xff\x79\x00\x00\x00\x2f\x07\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x03\x09\x00\x00"#
+
+alex_table :: AlexAddr
+alex_table = AlexA# "\x00\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x13\x00\x20\x00\x20\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x20\x00\x20\x00\x20\x00\x20\x00\x0c\x00\x1a\x00\x1e\x00\x10\x00\x20\x00\x17\x00\x20\x00\x25\x00\x20\x00\x20\x00\x20\x00\x20\x00\x1c\x00\x20\x00\x1d\x00\x24\x00\x1b\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x1f\x00\x20\x00\x23\x00\x22\x00\x1f\x00\x20\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x20\x00\x20\x00\x20\x00\x10\x00\x00\x00\x20\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x20\x00\x21\x00\x20\x00\x02\x00\x20\x00\x00\x00\x20\x00\x22\x00\x18\x00\x20\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x00\x00\x22\x00\x00\x00\x00\x00\x10\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x10\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x03\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x29\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x15\x00\x03\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0e\x00\x04\x00\x07\x00\x07\x00\x07\x00\x08\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
+
+alex_check :: AlexAddr
+alex_check = AlexA# "\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x2b\x00\x3d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3d\x00\x3e\x00\x7c\x00\x3e\x00\x2a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x2f\x00\x2e\x00\x26\x00\x26\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x22\x00\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x2a\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x2f\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x3e\x00\xff\xff\xff\xff\x5c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x74\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x22\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xff\xff\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
+
+alex_deflt :: AlexAddr
+alex_deflt = AlexA# "\xff\xff\x0c\x00\x0c\x00\xff\xff\xff\xff\x0c\x00\x0c\x00\x0d\x00\x0d\x00\x10\x00\xff\xff\x10\x00\x0c\x00\x16\x00\x16\x00\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\x17\x00\x17\x00\x17\x00\x17\x00\xff\xff\x0c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
+
+alex_accept = listArray (0::Int,42) [AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccNone,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAccSkip,AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_3),AlexAcc (alex_action_4),AlexAcc (alex_action_5),AlexAcc (alex_action_5),AlexAcc (alex_action_6),AlexAcc (alex_action_7)]
+{-# LINE 42 "src\Language\Clafer\Front\Lexclafer.x" #-}
+
+
+tok f p s = f p s
+
+share :: String -> String
+share = id
+
+data Tok =
+   TS !String !Int    -- reserved words and symbols
+ | TL !String         -- string literals
+ | TI !String         -- integer literals
+ | TV !String         -- identifiers
+ | TD !String         -- double precision float literals
+ | TC !String         -- character literals
+ | T_PosInteger !String
+ | T_PosDouble !String
+ | T_PosString !String
+ | T_PosIdent !String
+
+ deriving (Eq,Show,Ord)
+
+data Token = 
+   PT  Posn Tok
+ | Err Posn
+  deriving (Eq,Show,Ord)
+
+tokenPos (PT (Pn _ l _) _ :_) = "line " ++ show l
+tokenPos (Err (Pn _ l _) :_) = "line " ++ show l
+tokenPos _ = "end of file"
+
+tokenPosn (PT p _) = p
+tokenPosn (Err p) = p
+tokenLineCol = posLineCol . tokenPosn
+posLineCol (Pn _ l c) = (l,c)
+mkPosToken t@(PT p _) = (posLineCol p, prToken t)
+
+prToken t = case t of
+  PT _ (TS s _) -> s
+  PT _ (TL s)   -> s
+  PT _ (TI s)   -> s
+  PT _ (TV s)   -> s
+  PT _ (TD s)   -> s
+  PT _ (TC s)   -> s
+  PT _ (T_PosInteger s) -> s
+  PT _ (T_PosDouble s) -> s
+  PT _ (T_PosString s) -> s
+  PT _ (T_PosIdent s) -> s
+
+
+data BTree = N | B String Tok BTree BTree deriving (Show)
+
+eitherResIdent :: (String -> Tok) -> String -> Tok
+eitherResIdent tv s = treeFind resWords
+  where
+  treeFind N = tv s
+  treeFind (B a t left right) | s < a  = treeFind left
+                              | s > a  = treeFind right
+                              | s == a = t
+
+resWords = b ">=" 31 (b "." 16 (b "*" 8 (b "&" 4 (b "!=" 2 (b "!" 1 N N) (b "#" 3 N N)) (b "(" 6 (b "&&" 5 N N) (b ")" 7 N N))) (b "-" 12 (b "++" 10 (b "+" 9 N N) (b "," 11 N N)) (b "->" 14 (b "--" 13 N N) (b "->>" 15 N N)))) (b "<:" 24 (b ":=" 20 (b "/" 18 (b ".." 17 N N) (b ":" 19 N N)) (b ";" 22 (b ":>" 21 N N) (b "<" 23 N N))) (b "=" 28 (b "<=" 26 (b "<<" 25 N N) (b "<=>" 27 N N)) (b ">" 30 (b "=>" 29 N N) N)))) (b "min" 47 (b "all" 39 (b "\\" 35 (b "?" 33 (b ">>" 32 N N) (b "[" 34 N N)) (b "`" 37 (b "]" 36 N N) (b "abstract" 38 N N))) (b "if" 43 (b "else" 41 (b "disj" 40 N N) (b "enum" 42 N N)) (b "lone" 45 (b "in" 44 N N) (b "max" 46 N N)))) (b "sum" 55 (b "one" 51 (b "no" 49 (b "mux" 48 N N) (b "not" 50 N N)) (b "or" 53 (b "opt" 52 N N) (b "some" 54 N N))) (b "|" 59 (b "xor" 57 (b "then" 56 N N) (b "{" 58 N N)) (b "}" 61 (b "||" 60 N N) N))))
+   where b s n = let bs = id s
+                  in B bs (TS bs n)
+
+unescapeInitTail :: String -> String
+unescapeInitTail = id . unesc . tail . id where
+  unesc s = case s of
+    '\\':c:cs | elem c ['\"', '\\', '\''] -> c : unesc cs
+    '\\':'n':cs  -> '\n' : unesc cs
+    '\\':'t':cs  -> '\t' : unesc cs
+    '"':[]    -> []
+    c:cs      -> c : unesc cs
+    _         -> []
+
+-------------------------------------------------------------------
+-- Alex wrapper code.
+-- A modified "posn" wrapper.
+-------------------------------------------------------------------
+
+data Posn = Pn !Int !Int !Int
+      deriving (Eq, Show,Ord)
+
+alexStartPos :: Posn
+alexStartPos = Pn 0 1 1
+
+alexMove :: Posn -> Char -> Posn
+alexMove (Pn a l c) '\t' = Pn (a+1)  l     (((c+7) `div` 8)*8+1)
+alexMove (Pn a l c) '\n' = Pn (a+1) (l+1)   1
+alexMove (Pn a l c) _    = Pn (a+1)  l     (c+1)
+
+type Byte = Word8
+
+type AlexInput = (Posn,     -- current position,
+                  Char,     -- previous char
+                  [Byte],   -- pending bytes on the current char
+                  String)   -- current input string
+
+tokens :: String -> [Token]
+tokens str = go (alexStartPos, '\n', [], str)
+    where
+      go :: AlexInput -> [Token]
+      go inp@(pos, _, _, str) =
+               case alexScan inp 0 of
+                AlexEOF                   -> []
+                AlexError (pos, _, _, _)  -> [Err pos]
+                AlexSkip  inp' len        -> go inp'
+                AlexToken inp' len act    -> act pos (take len str) : (go inp')
+
+alexGetByte :: AlexInput -> Maybe (Byte,AlexInput)
+alexGetByte (p, c, (b:bs), s) = Just (b, (p, c, bs, s))
+alexGetByte (p, _, [], s) =
+  case  s of
+    []  -> Nothing
+    (c:s) ->
+             let p'     = alexMove p c
+                 (b:bs) = utf8Encode c
+              in p' `seq` Just (b, (p', c, bs, s))
+
+alexInputPrevChar :: AlexInput -> Char
+alexInputPrevChar (p, c, bs, s) = c
+
+-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
+utf8Encode :: Char -> [Word8]
+utf8Encode = map fromIntegral . go . ord
+ where
+  go oc
+   | oc <= 0x7f       = [oc]
+
+   | oc <= 0x7ff      = [ 0xc0 + (oc `Data.Bits.shiftR` 6)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+
+   | oc <= 0xffff     = [ 0xe0 + (oc `Data.Bits.shiftR` 12)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+   | otherwise        = [ 0xf0 + (oc `Data.Bits.shiftR` 18)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 12) Data.Bits..&. 0x3f)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+
+alex_action_3 =  tok (\p s -> PT p (eitherResIdent (TV . share) s)) 
+alex_action_4 =  tok (\p s -> PT p (eitherResIdent (T_PosInteger . share) s)) 
+alex_action_5 =  tok (\p s -> PT p (eitherResIdent (T_PosDouble . share) s)) 
+alex_action_6 =  tok (\p s -> PT p (eitherResIdent (T_PosString . share) s)) 
+alex_action_7 =  tok (\p s -> PT p (eitherResIdent (T_PosIdent . share) s)) 
+alex_action_8 =  tok (\p s -> PT p (eitherResIdent (TV . share) s)) 
+{-# LINE 1 "templates\GenericTemplate.hs" #-}
+{-# LINE 1 "templates\\GenericTemplate.hs" #-}
+{-# LINE 1 "<built-in>" #-}
+{-# LINE 1 "<command-line>" #-}
+{-# LINE 1 "templates\\GenericTemplate.hs" #-}
+-- -----------------------------------------------------------------------------
+-- ALEX TEMPLATE
+--
+-- This code is in the PUBLIC DOMAIN; you may copy it freely and use
+-- it for any purpose whatsoever.
+
+-- -----------------------------------------------------------------------------
+-- INTERNALS and main scanner engine
+
+{-# LINE 21 "templates\\GenericTemplate.hs" #-}
+
+
+
+
+
+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
+#if __GLASGOW_HASKELL__ > 706
+#define GTE(n,m) (tagToEnum# (n >=# m))
+#define EQ(n,m) (tagToEnum# (n ==# m))
+#else
+#define GTE(n,m) (n >=# m)
+#define EQ(n,m) (n ==# m)
+#endif
+{-# LINE 51 "templates\\GenericTemplate.hs" #-}
+
+
+data AlexAddr = AlexA# Addr#
+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
+#if __GLASGOW_HASKELL__ < 503
+uncheckedShiftL# = shiftL#
+#endif
+
+{-# INLINE alexIndexInt16OffAddr #-}
+alexIndexInt16OffAddr (AlexA# arr) off =
+#ifdef WORDS_BIGENDIAN
+  narrow16Int# i
+  where
+        i    = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)
+        high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))
+        low  = int2Word# (ord# (indexCharOffAddr# arr off'))
+        off' = off *# 2#
+#else
+  indexInt16OffAddr# arr off
+#endif
+
+
+
+
+
+{-# INLINE alexIndexInt32OffAddr #-}
+alexIndexInt32OffAddr (AlexA# arr) off = 
+#ifdef WORDS_BIGENDIAN
+  narrow32Int# i
+  where
+   i    = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`
+		     (b2 `uncheckedShiftL#` 16#) `or#`
+		     (b1 `uncheckedShiftL#` 8#) `or#` b0)
+   b3   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))
+   b2   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))
+   b1   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))
+   b0   = int2Word# (ord# (indexCharOffAddr# arr off'))
+   off' = off *# 4#
+#else
+  indexInt32OffAddr# arr off
+#endif
+
+
+
+
+
+
+#if __GLASGOW_HASKELL__ < 503
+quickIndex arr i = arr ! i
+#else
+-- GHC >= 503, unsafeAt is available from Data.Array.Base.
+quickIndex = unsafeAt
+#endif
+
+
+
+
+-- -----------------------------------------------------------------------------
+-- Main lexing routines
+
+data AlexReturn a
+  = AlexEOF
+  | AlexError  !AlexInput
+  | AlexSkip   !AlexInput !Int
+  | AlexToken  !AlexInput !Int a
+
+-- alexScan :: AlexInput -> StartCode -> AlexReturn a
+alexScan input (I# (sc))
+  = alexScanUser undefined input (I# (sc))
+
+alexScanUser user input (I# (sc))
+  = case alex_scan_tkn user input 0# input sc AlexNone of
+	(AlexNone, input') ->
+		case alexGetByte input of
+			Nothing -> 
+
+
+
+				   AlexEOF
+			Just _ ->
+
+
+
+				   AlexError input'
+
+	(AlexLastSkip input'' len, _) ->
+
+
+
+		AlexSkip input'' len
+
+	(AlexLastAcc k input''' len, _) ->
+
+
+
+		AlexToken input''' len k
+
+
+-- Push the input through the DFA, remembering the most recent accepting
+-- state it encountered.
+
+alex_scan_tkn user orig_input len input s last_acc =
+  input `seq` -- strict in the input
+  let 
+	new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))
+  in
+  new_acc `seq`
+  case alexGetByte input of
+     Nothing -> (new_acc, input)
+     Just (c, new_input) -> 
+
+
+
+      case fromIntegral c of { (I# (ord_c)) ->
+        let
+                base   = alexIndexInt32OffAddr alex_base s
+                offset = (base +# ord_c)
+                check  = alexIndexInt16OffAddr alex_check offset
+		
+                new_s = if GTE(offset,0#) && EQ(check,ord_c)
+			  then alexIndexInt16OffAddr alex_table offset
+			  else alexIndexInt16OffAddr alex_deflt s
+	in
+        case new_s of
+	    -1# -> (new_acc, input)
+		-- on an error, we want to keep the input *before* the
+		-- character that failed, not after.
+    	    _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)
+                                                -- note that the length is increased ONLY if this is the 1st byte in a char encoding)
+			new_input new_s new_acc
+      }
+  where
+	check_accs (AlexAccNone) = last_acc
+	check_accs (AlexAcc a  ) = AlexLastAcc a input (I# (len))
+	check_accs (AlexAccSkip) = AlexLastSkip  input (I# (len))
+{-# LINE 198 "templates\\GenericTemplate.hs" #-}
+
+data AlexLastAcc a
+  = AlexNone
+  | AlexLastAcc a !AlexInput !Int
+  | AlexLastSkip  !AlexInput !Int
+
+instance Functor AlexLastAcc where
+    fmap f AlexNone = AlexNone
+    fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z
+    fmap f (AlexLastSkip x y) = AlexLastSkip x y
+
+data AlexAcc a user
+  = AlexAccNone
+  | AlexAcc a
+  | AlexAccSkip
+{-# LINE 242 "templates\\GenericTemplate.hs" #-}
+
+-- used by wrappers
+iUnbox (I# (i)) = i
+ dist/build/Language/Clafer/Front/Parclafer.hs view
@@ -0,0 +1,2001 @@+{-# OPTIONS_GHC -w #-}
+{-# OPTIONS -fglasgow-exts -cpp #-}
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
+module Language.Clafer.Front.Parclafer where
+import Language.Clafer.Front.Absclafer
+import Language.Clafer.Front.Lexclafer
+import Language.Clafer.Front.ErrM
+import qualified Data.Array as Happy_Data_Array
+import qualified GHC.Exts as Happy_GHC_Exts
+import Control.Applicative(Applicative(..))
+
+-- parser produced by Happy Version 1.19.4
+
+newtype HappyAbsSyn  = HappyAbsSyn HappyAny
+#if __GLASGOW_HASKELL__ >= 607
+type HappyAny = Happy_GHC_Exts.Any
+#else
+type HappyAny = forall a . a
+#endif
+happyIn4 :: (PosInteger) -> (HappyAbsSyn )
+happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn4 #-}
+happyOut4 :: (HappyAbsSyn ) -> (PosInteger)
+happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut4 #-}
+happyIn5 :: (PosDouble) -> (HappyAbsSyn )
+happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn5 #-}
+happyOut5 :: (HappyAbsSyn ) -> (PosDouble)
+happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut5 #-}
+happyIn6 :: (PosString) -> (HappyAbsSyn )
+happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn6 #-}
+happyOut6 :: (HappyAbsSyn ) -> (PosString)
+happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut6 #-}
+happyIn7 :: (PosIdent) -> (HappyAbsSyn )
+happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn7 #-}
+happyOut7 :: (HappyAbsSyn ) -> (PosIdent)
+happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut7 #-}
+happyIn8 :: (Module) -> (HappyAbsSyn )
+happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn8 #-}
+happyOut8 :: (HappyAbsSyn ) -> (Module)
+happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut8 #-}
+happyIn9 :: (Declaration) -> (HappyAbsSyn )
+happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn9 #-}
+happyOut9 :: (HappyAbsSyn ) -> (Declaration)
+happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut9 #-}
+happyIn10 :: (Clafer) -> (HappyAbsSyn )
+happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn10 #-}
+happyOut10 :: (HappyAbsSyn ) -> (Clafer)
+happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut10 #-}
+happyIn11 :: (Constraint) -> (HappyAbsSyn )
+happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn11 #-}
+happyOut11 :: (HappyAbsSyn ) -> (Constraint)
+happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut11 #-}
+happyIn12 :: (SoftConstraint) -> (HappyAbsSyn )
+happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn12 #-}
+happyOut12 :: (HappyAbsSyn ) -> (SoftConstraint)
+happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut12 #-}
+happyIn13 :: (Goal) -> (HappyAbsSyn )
+happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn13 #-}
+happyOut13 :: (HappyAbsSyn ) -> (Goal)
+happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut13 #-}
+happyIn14 :: (Abstract) -> (HappyAbsSyn )
+happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn14 #-}
+happyOut14 :: (HappyAbsSyn ) -> (Abstract)
+happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut14 #-}
+happyIn15 :: (Elements) -> (HappyAbsSyn )
+happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn15 #-}
+happyOut15 :: (HappyAbsSyn ) -> (Elements)
+happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut15 #-}
+happyIn16 :: (Element) -> (HappyAbsSyn )
+happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn16 #-}
+happyOut16 :: (HappyAbsSyn ) -> (Element)
+happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut16 #-}
+happyIn17 :: (Super) -> (HappyAbsSyn )
+happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn17 #-}
+happyOut17 :: (HappyAbsSyn ) -> (Super)
+happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut17 #-}
+happyIn18 :: (SuperHow) -> (HappyAbsSyn )
+happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn18 #-}
+happyOut18 :: (HappyAbsSyn ) -> (SuperHow)
+happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut18 #-}
+happyIn19 :: (Init) -> (HappyAbsSyn )
+happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn19 #-}
+happyOut19 :: (HappyAbsSyn ) -> (Init)
+happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut19 #-}
+happyIn20 :: (InitHow) -> (HappyAbsSyn )
+happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn20 #-}
+happyOut20 :: (HappyAbsSyn ) -> (InitHow)
+happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut20 #-}
+happyIn21 :: (GCard) -> (HappyAbsSyn )
+happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn21 #-}
+happyOut21 :: (HappyAbsSyn ) -> (GCard)
+happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut21 #-}
+happyIn22 :: (Card) -> (HappyAbsSyn )
+happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn22 #-}
+happyOut22 :: (HappyAbsSyn ) -> (Card)
+happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut22 #-}
+happyIn23 :: (NCard) -> (HappyAbsSyn )
+happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn23 #-}
+happyOut23 :: (HappyAbsSyn ) -> (NCard)
+happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut23 #-}
+happyIn24 :: (ExInteger) -> (HappyAbsSyn )
+happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn24 #-}
+happyOut24 :: (HappyAbsSyn ) -> (ExInteger)
+happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut24 #-}
+happyIn25 :: (Name) -> (HappyAbsSyn )
+happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn25 #-}
+happyOut25 :: (HappyAbsSyn ) -> (Name)
+happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut25 #-}
+happyIn26 :: (Exp) -> (HappyAbsSyn )
+happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn26 #-}
+happyOut26 :: (HappyAbsSyn ) -> (Exp)
+happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut26 #-}
+happyIn27 :: (Exp) -> (HappyAbsSyn )
+happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn27 #-}
+happyOut27 :: (HappyAbsSyn ) -> (Exp)
+happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut27 #-}
+happyIn28 :: (Exp) -> (HappyAbsSyn )
+happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn28 #-}
+happyOut28 :: (HappyAbsSyn ) -> (Exp)
+happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut28 #-}
+happyIn29 :: (Exp) -> (HappyAbsSyn )
+happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn29 #-}
+happyOut29 :: (HappyAbsSyn ) -> (Exp)
+happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut29 #-}
+happyIn30 :: (Exp) -> (HappyAbsSyn )
+happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn30 #-}
+happyOut30 :: (HappyAbsSyn ) -> (Exp)
+happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut30 #-}
+happyIn31 :: (Exp) -> (HappyAbsSyn )
+happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn31 #-}
+happyOut31 :: (HappyAbsSyn ) -> (Exp)
+happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut31 #-}
+happyIn32 :: (Exp) -> (HappyAbsSyn )
+happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn32 #-}
+happyOut32 :: (HappyAbsSyn ) -> (Exp)
+happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut32 #-}
+happyIn33 :: (Exp) -> (HappyAbsSyn )
+happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn33 #-}
+happyOut33 :: (HappyAbsSyn ) -> (Exp)
+happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut33 #-}
+happyIn34 :: (Exp) -> (HappyAbsSyn )
+happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn34 #-}
+happyOut34 :: (HappyAbsSyn ) -> (Exp)
+happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut34 #-}
+happyIn35 :: (Exp) -> (HappyAbsSyn )
+happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn35 #-}
+happyOut35 :: (HappyAbsSyn ) -> (Exp)
+happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut35 #-}
+happyIn36 :: (Exp) -> (HappyAbsSyn )
+happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn36 #-}
+happyOut36 :: (HappyAbsSyn ) -> (Exp)
+happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut36 #-}
+happyIn37 :: (Exp) -> (HappyAbsSyn )
+happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn37 #-}
+happyOut37 :: (HappyAbsSyn ) -> (Exp)
+happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut37 #-}
+happyIn38 :: (Exp) -> (HappyAbsSyn )
+happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn38 #-}
+happyOut38 :: (HappyAbsSyn ) -> (Exp)
+happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut38 #-}
+happyIn39 :: (Exp) -> (HappyAbsSyn )
+happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn39 #-}
+happyOut39 :: (HappyAbsSyn ) -> (Exp)
+happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut39 #-}
+happyIn40 :: (SetExp) -> (HappyAbsSyn )
+happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn40 #-}
+happyOut40 :: (HappyAbsSyn ) -> (SetExp)
+happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut40 #-}
+happyIn41 :: (SetExp) -> (HappyAbsSyn )
+happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn41 #-}
+happyOut41 :: (HappyAbsSyn ) -> (SetExp)
+happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut41 #-}
+happyIn42 :: (SetExp) -> (HappyAbsSyn )
+happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn42 #-}
+happyOut42 :: (HappyAbsSyn ) -> (SetExp)
+happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut42 #-}
+happyIn43 :: (SetExp) -> (HappyAbsSyn )
+happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn43 #-}
+happyOut43 :: (HappyAbsSyn ) -> (SetExp)
+happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut43 #-}
+happyIn44 :: (SetExp) -> (HappyAbsSyn )
+happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn44 #-}
+happyOut44 :: (HappyAbsSyn ) -> (SetExp)
+happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut44 #-}
+happyIn45 :: (SetExp) -> (HappyAbsSyn )
+happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn45 #-}
+happyOut45 :: (HappyAbsSyn ) -> (SetExp)
+happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut45 #-}
+happyIn46 :: (SetExp) -> (HappyAbsSyn )
+happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn46 #-}
+happyOut46 :: (HappyAbsSyn ) -> (SetExp)
+happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut46 #-}
+happyIn47 :: (Decl) -> (HappyAbsSyn )
+happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn47 #-}
+happyOut47 :: (HappyAbsSyn ) -> (Decl)
+happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut47 #-}
+happyIn48 :: (Quant) -> (HappyAbsSyn )
+happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn48 #-}
+happyOut48 :: (HappyAbsSyn ) -> (Quant)
+happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut48 #-}
+happyIn49 :: (EnumId) -> (HappyAbsSyn )
+happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn49 #-}
+happyOut49 :: (HappyAbsSyn ) -> (EnumId)
+happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut49 #-}
+happyIn50 :: (ModId) -> (HappyAbsSyn )
+happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn50 #-}
+happyOut50 :: (HappyAbsSyn ) -> (ModId)
+happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut50 #-}
+happyIn51 :: (LocId) -> (HappyAbsSyn )
+happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn51 #-}
+happyOut51 :: (HappyAbsSyn ) -> (LocId)
+happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut51 #-}
+happyIn52 :: ([Declaration]) -> (HappyAbsSyn )
+happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn52 #-}
+happyOut52 :: (HappyAbsSyn ) -> ([Declaration])
+happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut52 #-}
+happyIn53 :: ([EnumId]) -> (HappyAbsSyn )
+happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn53 #-}
+happyOut53 :: (HappyAbsSyn ) -> ([EnumId])
+happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut53 #-}
+happyIn54 :: ([Element]) -> (HappyAbsSyn )
+happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn54 #-}
+happyOut54 :: (HappyAbsSyn ) -> ([Element])
+happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut54 #-}
+happyIn55 :: ([Exp]) -> (HappyAbsSyn )
+happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn55 #-}
+happyOut55 :: (HappyAbsSyn ) -> ([Exp])
+happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut55 #-}
+happyIn56 :: ([LocId]) -> (HappyAbsSyn )
+happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn56 #-}
+happyOut56 :: (HappyAbsSyn ) -> ([LocId])
+happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut56 #-}
+happyIn57 :: ([ModId]) -> (HappyAbsSyn )
+happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyIn57 #-}
+happyOut57 :: (HappyAbsSyn ) -> ([ModId])
+happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOut57 #-}
+happyInTok :: (Token) -> (HappyAbsSyn )
+happyInTok x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyInTok #-}
+happyOutTok :: (HappyAbsSyn ) -> (Token)
+happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x
+{-# INLINE happyOutTok #-}
+
+
+happyActOffsets :: HappyAddr
+happyActOffsets = HappyA# "\x00\x00\x1b\x01\x00\x00\x17\x01\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x00\x00\x16\x01\x3a\x01\x00\x00\x00\x00\x09\x00\x32\x01\x00\x00\x54\x00\x1d\x00\x01\x00\x41\x01\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x2a\x01\xf3\x00\xf7\x00\x29\x01\x00\x00\x8d\x05\x00\x00\xb6\x00\x03\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x20\x01\x28\x01\x10\x01\x11\x01\x13\x01\x00\x00\xb4\x00\x8a\x00\xfb\xff\x70\x00\x00\x00\xfb\xff\xde\xff\xfb\xff\x00\x00\xa7\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\xff\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x07\x01\xc2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\xfb\xff\xd4\x00\xb2\x00\x00\x00\xb1\x00\xcc\x00\xce\x00\xa8\x00\x00\x00\xcf\x00\x0c\x00\x00\x00\x8d\x05\x76\x00\x00\x00\xa0\x00\x94\x00\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xc0\x00\xc0\x00\xc0\x00\xc0\x00\x8a\x00\x8a\x00\x8a\x00\x8a\x00\x8a\x00\x8a\x00\x8a\x00\x9b\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x09\x00\xfd\xff\x00\x00\x00\x00\x00\x00\x0f\x00\xfd\xff\xfc\xff\xa1\x00\x89\x00\x80\x00\xaf\x00\x00\x00\x8a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x03\x00\x00\x00\x00\x00\xab\x00\xab\x00\xa5\x00\x82\x00\x8f\x00\x7f\x00\x00\x00\x5d\x00\x70\x00\x00\x00\x00\x00\x56\x00\xfd\xff\x4d\x00\x70\x00\xfb\xff\xbe\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x0f\x00\x70\x00\x00\x00\x70\x00\x00\x00\x36\x00\x70\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00"#
+
+happyGotoOffsets :: HappyAddr
+happyGotoOffsets = HappyA# "\x05\x00\x00\x00\x00\x00\x00\x00\x7c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x00\x00\x44\x00\x3c\x00\x1e\x00\x18\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x00\x00\x07\x02\x07\x02\x07\x02\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x57\x04\x7f\x03\x5d\x05\xd8\x01\x00\x00\x43\x05\xf6\x00\x2d\x05\x00\x00\x94\x02\x65\x02\x00\x00\x00\x00\x00\x00\x00\x00\x13\x05\x00\x00\x00\x00\x00\x00\x00\x00\x33\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xff\x00\x00\x00\x00\x00\x00\xfd\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x4f\x00\x18\x06\x02\x06\xf9\x05\xea\x05\xe1\x05\xcb\x05\xcd\x04\xb3\x04\x9d\x04\x6e\x04\x3f\x04\x27\x04\x0f\x04\xf7\x03\xdf\x03\xc7\x03\xaf\x03\x00\x00\x50\x03\x21\x03\xf2\x02\xc3\x02\x36\x02\x00\x00\x00\x00\x00\x00\x0a\x00\xb5\x05\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x05\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x01\x00\x00\x00\x00\x00\x00\x89\x05\x46\x00\x7a\x01\xe3\x04\xc7\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x01\x00\x00\x1c\x01\x00\x00\xfa\xff\xed\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x05\x00\x00\x00\x00"#
+
+happyDefActions :: HappyAddr
+happyDefActions = HappyA# "\x8a\xff\x00\x00\xfe\xff\x00\x00\xf3\xff\x89\xff\xef\xff\xed\xff\xeb\xff\xec\xff\xe1\xff\xf8\xff\x84\xff\x84\xff\x84\xff\x00\x00\xf2\xff\x00\x00\x00\x00\xfb\xff\x8c\xff\xdb\xff\x80\xff\xd2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xff\xde\xff\xdd\xff\xdf\xff\xe0\xff\xea\xff\x00\x00\xa7\xff\xa6\xff\xa5\xff\x95\xff\x83\xff\xcd\xff\xc9\xff\xc7\xff\xc5\xff\xc3\xff\xc1\xff\xbf\xff\xb6\xff\xb4\xff\xb1\xff\xae\xff\xaa\xff\xa8\xff\xa4\xff\xa0\xff\x9e\xff\x9c\xff\x9a\xff\x98\xff\x96\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf5\xff\x00\x00\x00\x00\x00\x00\x90\xff\x00\x00\x00\x00\x92\xff\x91\xff\x8f\xff\x8e\xff\x00\x00\xfd\xff\xfc\xff\xf4\xff\xf6\xff\x00\x00\xd7\xff\xf1\xff\xd6\xff\xd8\xff\xd9\xff\xda\xff\x00\x00\x8d\xff\x88\xff\xf9\xff\xee\xff\x86\xff\x7f\xff\xad\xff\xcb\xff\x00\x00\xcc\xff\x00\x00\x8b\xff\x00\x00\x82\xff\x00\x00\x00\x00\xab\xff\x00\x00\xa4\xff\xac\xff\xc0\xff\x8c\xff\xb5\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xff\xd5\xff\xd4\xff\xdb\xff\x00\x00\xe7\xff\xe6\xff\xe8\xff\xe9\xff\x00\x00\xe5\xff\xca\xff\xc8\xff\xc6\xff\xc4\xff\xc2\xff\x00\x00\xb8\xff\xba\xff\xbd\xff\xbc\xff\xbb\xff\xbe\xff\xb9\xff\xb2\xff\xb3\xff\xaf\xff\xb0\xff\xa1\xff\xa2\xff\x9f\xff\x9d\xff\x9b\xff\x99\xff\x97\xff\x00\x00\x00\x00\x94\xff\xa3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\xff\x00\x00\x87\xff\x85\xff\xf0\xff\x00\x00\xd0\xff\x81\xff\x93\xff\x00\x00\xce\xff\x00\x00\xb7\xff\xf1\xff\x00\x00\xe2\xff\xe3\xff\x00\x00\xe4\xff\xf7\xff\xcf\xff\xd1\xff\x00\x00\xa9\xff"#
+
+happyCheck :: HappyAddr
+happyCheck = HappyA# "\xff\xff\x06\x00\x01\x00\x06\x00\x03\x00\x0b\x00\x28\x00\x06\x00\x07\x00\x04\x00\x00\x00\x08\x00\x32\x00\x0c\x00\x00\x00\x08\x00\x14\x00\x08\x00\x09\x00\x07\x00\x00\x00\x12\x00\x0a\x00\x0b\x00\x1c\x00\x0a\x00\x0b\x00\x03\x00\x12\x00\x13\x00\x01\x00\x41\x00\x03\x00\x0b\x00\x14\x00\x06\x00\x03\x00\x11\x00\x2b\x00\x13\x00\x27\x00\x0c\x00\x21\x00\x03\x00\x2b\x00\x15\x00\x2d\x00\x2e\x00\x2f\x00\x06\x00\x31\x00\x32\x00\x33\x00\x30\x00\x03\x00\x36\x00\x37\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x20\x00\x41\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x06\x00\x27\x00\x3e\x00\x2e\x00\x3e\x00\x2b\x00\x03\x00\x2d\x00\x2e\x00\x2f\x00\x35\x00\x31\x00\x32\x00\x33\x00\x33\x00\x03\x00\x36\x00\x37\x00\x01\x00\x19\x00\x03\x00\x0f\x00\x10\x00\x06\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x22\x00\x0c\x00\x2e\x00\x25\x00\x26\x00\x15\x00\x0d\x00\x0e\x00\x2a\x00\x35\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x0e\x00\x0f\x00\x33\x00\x3a\x00\x01\x00\x13\x00\x03\x00\x03\x00\x2f\x00\x06\x00\x33\x00\x24\x00\x2a\x00\x34\x00\x27\x00\x0c\x00\x2e\x00\x29\x00\x2b\x00\x43\x00\x2d\x00\x2e\x00\x2f\x00\x35\x00\x31\x00\x32\x00\x33\x00\x03\x00\x13\x00\x36\x00\x37\x00\x16\x00\x03\x00\x41\x00\x10\x00\x06\x00\x3b\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x0c\x00\x27\x00\x3b\x00\x00\x00\x18\x00\x2b\x00\x2b\x00\x2d\x00\x2e\x00\x2f\x00\x2f\x00\x31\x00\x32\x00\x33\x00\x15\x00\x34\x00\x36\x00\x37\x00\x01\x00\x04\x00\x03\x00\x12\x00\x13\x00\x06\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x2d\x00\x0c\x00\x05\x00\x2b\x00\x31\x00\x2d\x00\x0d\x00\x39\x00\x06\x00\x31\x00\x32\x00\x33\x00\x1d\x00\x09\x00\x36\x00\x37\x00\x0c\x00\x03\x00\x06\x00\x3c\x00\x06\x00\x2c\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x0c\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x2b\x00\x0c\x00\x2d\x00\x41\x00\x07\x00\x19\x00\x31\x00\x32\x00\x33\x00\x3b\x00\x28\x00\x36\x00\x37\x00\x2b\x00\x22\x00\x13\x00\x16\x00\x25\x00\x26\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x41\x00\x38\x00\x2b\x00\x3b\x00\x00\x00\x01\x00\x02\x00\x03\x00\x1d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x3b\x00\x37\x00\x03\x00\x03\x00\x41\x00\x3d\x00\x3a\x00\x03\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x11\x00\x2c\x00\x41\x00\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x2b\x00\x2b\x00\x35\x00\x10\x00\x2f\x00\x2f\x00\x15\x00\x2d\x00\x18\x00\x34\x00\x34\x00\x31\x00\x04\x00\x0d\x00\x05\x00\x3c\x00\x39\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x1d\x00\x2c\x00\x1b\x00\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x30\x00\x41\x00\x35\x00\x11\x00\x34\x00\x35\x00\x23\x00\x1c\x00\x41\x00\x39\x00\x3e\x00\x43\x00\xff\xff\xff\xff\x3e\x00\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\xff\xff\x0c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x2c\x00\x15\x00\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x15\x00\xff\xff\x2e\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x15\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x15\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x15\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\xff\xff\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\x15\x00\x00\x00\x01\x00\x02\x00\x03\x00\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\x03\x00\xff\xff\xff\xff\x02\x00\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\x03\x00\xff\xff\x17\x00\xff\xff\xff\xff\x1a\x00\x35\x00\x1c\x00\xff\xff\x1e\x00\x1f\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\x03\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x32\x00\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\x03\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\x03\x00\xff\xff\xff\xff\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x15\x00\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\x03\x00\xff\xff\xff\xff\x15\x00\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\x03\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\x15\x00\x2e\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\x35\x00\x15\x00\x2e\x00\xff\xff\xff\xff\x03\x00\xff\xff\xff\xff\xff\xff\x35\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\x28\x00\x29\x00\x2a\x00\x15\x00\x35\x00\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
+
+happyTable :: HappyAddr
+happyTable = HappyA# "\x00\x00\x41\x00\x3f\x00\x94\x00\x40\x00\xc9\x00\x69\x00\x41\x00\x42\x00\x03\x00\x52\x00\x7a\x00\xb6\x00\x43\x00\x8a\x00\x8d\x00\xc6\x00\x56\x00\x57\x00\xb0\x00\x1b\x00\x7b\x00\x78\x00\x79\x00\xc7\x00\x78\x00\x79\x00\x14\x00\x94\x00\x54\x00\x3f\x00\x14\x00\x40\x00\x5c\x00\x8b\x00\x41\x00\x22\x00\x1c\x00\x45\x00\x1d\x00\x44\x00\x43\x00\x58\x00\x12\x00\x45\x00\x15\x00\x46\x00\x47\x00\x48\x00\x41\x00\x49\x00\x4a\x00\x4b\x00\x04\x00\x14\x00\x4c\x00\x4d\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x50\x00\x14\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x0d\x00\x44\x00\x03\x00\x16\x00\x03\x00\x45\x00\x64\x00\x46\x00\x47\x00\x48\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x18\x00\x14\x00\x4c\x00\x4d\x00\x3f\x00\x0e\x00\x40\x00\xc3\x00\xc4\x00\x41\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x0f\x00\x43\x00\x16\x00\x10\x00\x11\x00\x27\x00\x8d\x00\x8e\x00\x12\x00\x5e\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x90\x00\x91\x00\x19\x00\x5e\x00\x3f\x00\x92\x00\x40\x00\x64\x00\x66\x00\x41\x00\x1a\x00\x51\x00\xac\x00\xbd\x00\x44\x00\x43\x00\x16\x00\xcd\x00\x45\x00\xfa\xff\x46\x00\x47\x00\x48\x00\x17\x00\x49\x00\x4a\x00\x4b\x00\x59\x00\x8b\xff\x4c\x00\x4d\x00\x8b\xff\x40\x00\x14\x00\x73\x00\x41\x00\xc0\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x43\x00\x44\x00\xc2\x00\x52\x00\x75\x00\x45\x00\xad\x00\x46\x00\x47\x00\x48\x00\x66\x00\x49\x00\x4a\x00\x4b\x00\x74\x00\x67\x00\x4c\x00\x4d\x00\x3f\x00\x76\x00\x40\x00\x53\x00\x54\x00\x41\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x5a\x00\x43\x00\x86\x00\x45\x00\xb8\x00\x46\x00\x77\x00\x87\x00\x41\x00\x49\x00\x4a\x00\x4b\x00\x89\x00\x7c\x00\x4c\x00\x4d\x00\x7d\x00\x40\x00\x0d\x00\x88\x00\x41\x00\x9b\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x43\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x45\x00\xb9\x00\x46\x00\x14\x00\xb1\x00\x0e\x00\x49\x00\x4a\x00\x4b\x00\xaf\x00\x72\x00\x4c\x00\x4d\x00\x45\x00\x0f\x00\xb3\x00\xb4\x00\x10\x00\x11\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x14\x00\xb6\x00\x45\x00\xb5\x00\x24\x00\x25\x00\x26\x00\x14\x00\x89\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\xb8\x00\x4d\x00\x64\x00\x64\x00\x14\x00\xbb\x00\x5e\x00\x59\x00\x03\x00\x4e\x00\x4f\x00\x14\x00\x27\x00\xc8\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x24\x00\x3d\x00\x14\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\xb1\x00\x65\x00\x17\x00\x73\x00\x66\x00\x66\x00\x74\x00\x5a\x00\x75\x00\x67\x00\x67\x00\x5b\x00\x76\x00\x77\x00\x86\x00\x88\x00\x87\x00\x27\x00\xca\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x89\x00\x3d\x00\x8a\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x1f\x00\x14\x00\x17\x00\x24\x00\x20\x00\x21\x00\x52\x00\x59\x00\x14\x00\x22\x00\x03\x00\xff\xff\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x27\x00\xcb\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\xbc\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\xc0\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x6a\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x6b\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x3d\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x95\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x60\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x62\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x00\x00\x96\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x00\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x6d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\xc2\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x9b\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x9c\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x9d\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x9e\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x9f\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\xa0\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x6e\x00\x00\x00\x17\x00\xa1\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x61\x00\x27\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x70\x00\x27\x00\x00\x00\x16\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x17\x00\x00\x00\xa2\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\xa4\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x27\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\xbb\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x27\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\x5f\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x27\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x00\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\x69\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x27\x00\x24\x00\x25\x00\x26\x00\x14\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x14\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x14\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x80\x00\x17\x00\x81\x00\x00\x00\x82\x00\x83\x00\xbe\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x14\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x85\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\xa6\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x27\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x27\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\xa7\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x27\x00\x16\x00\xa8\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x17\x00\x27\x00\x16\x00\x00\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x17\x00\xa9\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\xaa\x00\x3b\x00\x3c\x00\x27\x00\x17\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
+
+happyReduceArr = Happy_Data_Array.array (1, 128) [
+	(1 , happyReduce_1),
+	(2 , happyReduce_2),
+	(3 , happyReduce_3),
+	(4 , happyReduce_4),
+	(5 , happyReduce_5),
+	(6 , happyReduce_6),
+	(7 , happyReduce_7),
+	(8 , happyReduce_8),
+	(9 , happyReduce_9),
+	(10 , happyReduce_10),
+	(11 , happyReduce_11),
+	(12 , happyReduce_12),
+	(13 , happyReduce_13),
+	(14 , happyReduce_14),
+	(15 , happyReduce_15),
+	(16 , happyReduce_16),
+	(17 , happyReduce_17),
+	(18 , happyReduce_18),
+	(19 , happyReduce_19),
+	(20 , happyReduce_20),
+	(21 , happyReduce_21),
+	(22 , happyReduce_22),
+	(23 , happyReduce_23),
+	(24 , happyReduce_24),
+	(25 , happyReduce_25),
+	(26 , happyReduce_26),
+	(27 , happyReduce_27),
+	(28 , happyReduce_28),
+	(29 , happyReduce_29),
+	(30 , happyReduce_30),
+	(31 , happyReduce_31),
+	(32 , happyReduce_32),
+	(33 , happyReduce_33),
+	(34 , happyReduce_34),
+	(35 , happyReduce_35),
+	(36 , happyReduce_36),
+	(37 , happyReduce_37),
+	(38 , happyReduce_38),
+	(39 , happyReduce_39),
+	(40 , happyReduce_40),
+	(41 , happyReduce_41),
+	(42 , happyReduce_42),
+	(43 , happyReduce_43),
+	(44 , happyReduce_44),
+	(45 , happyReduce_45),
+	(46 , happyReduce_46),
+	(47 , happyReduce_47),
+	(48 , happyReduce_48),
+	(49 , happyReduce_49),
+	(50 , happyReduce_50),
+	(51 , happyReduce_51),
+	(52 , happyReduce_52),
+	(53 , happyReduce_53),
+	(54 , happyReduce_54),
+	(55 , happyReduce_55),
+	(56 , happyReduce_56),
+	(57 , happyReduce_57),
+	(58 , happyReduce_58),
+	(59 , happyReduce_59),
+	(60 , happyReduce_60),
+	(61 , happyReduce_61),
+	(62 , happyReduce_62),
+	(63 , happyReduce_63),
+	(64 , happyReduce_64),
+	(65 , happyReduce_65),
+	(66 , happyReduce_66),
+	(67 , happyReduce_67),
+	(68 , happyReduce_68),
+	(69 , happyReduce_69),
+	(70 , happyReduce_70),
+	(71 , happyReduce_71),
+	(72 , happyReduce_72),
+	(73 , happyReduce_73),
+	(74 , happyReduce_74),
+	(75 , happyReduce_75),
+	(76 , happyReduce_76),
+	(77 , happyReduce_77),
+	(78 , happyReduce_78),
+	(79 , happyReduce_79),
+	(80 , happyReduce_80),
+	(81 , happyReduce_81),
+	(82 , happyReduce_82),
+	(83 , happyReduce_83),
+	(84 , happyReduce_84),
+	(85 , happyReduce_85),
+	(86 , happyReduce_86),
+	(87 , happyReduce_87),
+	(88 , happyReduce_88),
+	(89 , happyReduce_89),
+	(90 , happyReduce_90),
+	(91 , happyReduce_91),
+	(92 , happyReduce_92),
+	(93 , happyReduce_93),
+	(94 , happyReduce_94),
+	(95 , happyReduce_95),
+	(96 , happyReduce_96),
+	(97 , happyReduce_97),
+	(98 , happyReduce_98),
+	(99 , happyReduce_99),
+	(100 , happyReduce_100),
+	(101 , happyReduce_101),
+	(102 , happyReduce_102),
+	(103 , happyReduce_103),
+	(104 , happyReduce_104),
+	(105 , happyReduce_105),
+	(106 , happyReduce_106),
+	(107 , happyReduce_107),
+	(108 , happyReduce_108),
+	(109 , happyReduce_109),
+	(110 , happyReduce_110),
+	(111 , happyReduce_111),
+	(112 , happyReduce_112),
+	(113 , happyReduce_113),
+	(114 , happyReduce_114),
+	(115 , happyReduce_115),
+	(116 , happyReduce_116),
+	(117 , happyReduce_117),
+	(118 , happyReduce_118),
+	(119 , happyReduce_119),
+	(120 , happyReduce_120),
+	(121 , happyReduce_121),
+	(122 , happyReduce_122),
+	(123 , happyReduce_123),
+	(124 , happyReduce_124),
+	(125 , happyReduce_125),
+	(126 , happyReduce_126),
+	(127 , happyReduce_127),
+	(128 , happyReduce_128)
+	]
+
+happy_n_terms = 68 :: Int
+happy_n_nonterms = 54 :: Int
+
+happyReduce_1 = happySpecReduce_1  0# happyReduction_1
+happyReduction_1 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn4
+		 (PosInteger (mkPosToken happy_var_1)
+	)}
+
+happyReduce_2 = happySpecReduce_1  1# happyReduction_2
+happyReduction_2 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn5
+		 (PosDouble (mkPosToken happy_var_1)
+	)}
+
+happyReduce_3 = happySpecReduce_1  2# happyReduction_3
+happyReduction_3 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn6
+		 (PosString (mkPosToken happy_var_1)
+	)}
+
+happyReduce_4 = happySpecReduce_1  3# happyReduction_4
+happyReduction_4 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn7
+		 (PosIdent (mkPosToken happy_var_1)
+	)}
+
+happyReduce_5 = happySpecReduce_1  4# happyReduction_5
+happyReduction_5 happy_x_1
+	 =  case happyOut52 happy_x_1 of { happy_var_1 -> 
+	happyIn8
+		 (Module ((mkCatSpan happy_var_1)) (reverse happy_var_1)
+	)}
+
+happyReduce_6 = happyReduce 4# 5# happyReduction_6
+happyReduction_6 (happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut7 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	case happyOut53 happy_x_4 of { happy_var_4 -> 
+	happyIn9
+		 (EnumDecl ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+	) `HappyStk` happyRest}}}}
+
+happyReduce_7 = happySpecReduce_1  5# happyReduction_7
+happyReduction_7 happy_x_1
+	 =  case happyOut16 happy_x_1 of { happy_var_1 -> 
+	happyIn9
+		 (ElementDecl ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_8 = happyReduce 7# 6# happyReduction_8
+happyReduction_8 (happy_x_7 `HappyStk`
+	happy_x_6 `HappyStk`
+	happy_x_5 `HappyStk`
+	happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOut14 happy_x_1 of { happy_var_1 -> 
+	case happyOut21 happy_x_2 of { happy_var_2 -> 
+	case happyOut7 happy_x_3 of { happy_var_3 -> 
+	case happyOut17 happy_x_4 of { happy_var_4 -> 
+	case happyOut22 happy_x_5 of { happy_var_5 -> 
+	case happyOut19 happy_x_6 of { happy_var_6 -> 
+	case happyOut15 happy_x_7 of { happy_var_7 -> 
+	happyIn10
+		 (Clafer ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkCatSpan happy_var_5) >- (mkCatSpan happy_var_6) >- (mkCatSpan happy_var_7)) happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_5 happy_var_6 happy_var_7
+	) `HappyStk` happyRest}}}}}}}
+
+happyReduce_9 = happySpecReduce_3  7# happyReduction_9
+happyReduction_9 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut55 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	happyIn11
+		 (Constraint ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
+	)}}}
+
+happyReduce_10 = happySpecReduce_3  8# happyReduction_10
+happyReduction_10 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut55 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	happyIn12
+		 (SoftConstraint ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
+	)}}}
+
+happyReduce_11 = happySpecReduce_3  9# happyReduction_11
+happyReduction_11 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut55 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	happyIn13
+		 (Goal ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
+	)}}}
+
+happyReduce_12 = happySpecReduce_0  10# happyReduction_12
+happyReduction_12  =  happyIn14
+		 (AbstractEmpty noSpan
+	)
+
+happyReduce_13 = happySpecReduce_1  10# happyReduction_13
+happyReduction_13 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn14
+		 (Abstract ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_14 = happySpecReduce_0  11# happyReduction_14
+happyReduction_14  =  happyIn15
+		 (ElementsEmpty noSpan
+	)
+
+happyReduce_15 = happySpecReduce_3  11# happyReduction_15
+happyReduction_15 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut54 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	happyIn15
+		 (ElementsList ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3)) (reverse happy_var_2)
+	)}}}
+
+happyReduce_16 = happySpecReduce_1  12# happyReduction_16
+happyReduction_16 happy_x_1
+	 =  case happyOut10 happy_x_1 of { happy_var_1 -> 
+	happyIn16
+		 (Subclafer ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_17 = happyReduce 4# 12# happyReduction_17
+happyReduction_17 (happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut25 happy_x_2 of { happy_var_2 -> 
+	case happyOut22 happy_x_3 of { happy_var_3 -> 
+	case happyOut15 happy_x_4 of { happy_var_4 -> 
+	happyIn16
+		 (ClaferUse ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_3 happy_var_4
+	) `HappyStk` happyRest}}}}
+
+happyReduce_18 = happySpecReduce_1  12# happyReduction_18
+happyReduction_18 happy_x_1
+	 =  case happyOut11 happy_x_1 of { happy_var_1 -> 
+	happyIn16
+		 (Subconstraint ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_19 = happySpecReduce_1  12# happyReduction_19
+happyReduction_19 happy_x_1
+	 =  case happyOut13 happy_x_1 of { happy_var_1 -> 
+	happyIn16
+		 (Subgoal ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_20 = happySpecReduce_1  12# happyReduction_20
+happyReduction_20 happy_x_1
+	 =  case happyOut12 happy_x_1 of { happy_var_1 -> 
+	happyIn16
+		 (Subsoftconstraint ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_21 = happySpecReduce_0  13# happyReduction_21
+happyReduction_21  =  happyIn17
+		 (SuperEmpty noSpan
+	)
+
+happyReduce_22 = happySpecReduce_2  13# happyReduction_22
+happyReduction_22 happy_x_2
+	happy_x_1
+	 =  case happyOut18 happy_x_1 of { happy_var_1 -> 
+	case happyOut40 happy_x_2 of { happy_var_2 -> 
+	happyIn17
+		 (SuperSome ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
+	)}}
+
+happyReduce_23 = happySpecReduce_1  14# happyReduction_23
+happyReduction_23 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn18
+		 (SuperColon ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_24 = happySpecReduce_1  14# happyReduction_24
+happyReduction_24 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn18
+		 (SuperArrow ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_25 = happySpecReduce_1  14# happyReduction_25
+happyReduction_25 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn18
+		 (SuperMArrow ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_26 = happySpecReduce_0  15# happyReduction_26
+happyReduction_26  =  happyIn19
+		 (InitEmpty noSpan
+	)
+
+happyReduce_27 = happySpecReduce_2  15# happyReduction_27
+happyReduction_27 happy_x_2
+	happy_x_1
+	 =  case happyOut20 happy_x_1 of { happy_var_1 -> 
+	case happyOut26 happy_x_2 of { happy_var_2 -> 
+	happyIn19
+		 (InitSome ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
+	)}}
+
+happyReduce_28 = happySpecReduce_1  16# happyReduction_28
+happyReduction_28 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn20
+		 (InitHow_1 ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_29 = happySpecReduce_1  16# happyReduction_29
+happyReduction_29 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn20
+		 (InitHow_2 ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_30 = happySpecReduce_0  17# happyReduction_30
+happyReduction_30  =  happyIn21
+		 (GCardEmpty noSpan
+	)
+
+happyReduce_31 = happySpecReduce_1  17# happyReduction_31
+happyReduction_31 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn21
+		 (GCardXor ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_32 = happySpecReduce_1  17# happyReduction_32
+happyReduction_32 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn21
+		 (GCardOr ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_33 = happySpecReduce_1  17# happyReduction_33
+happyReduction_33 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn21
+		 (GCardMux ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_34 = happySpecReduce_1  17# happyReduction_34
+happyReduction_34 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn21
+		 (GCardOpt ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_35 = happySpecReduce_1  17# happyReduction_35
+happyReduction_35 happy_x_1
+	 =  case happyOut23 happy_x_1 of { happy_var_1 -> 
+	happyIn21
+		 (GCardInterval ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_36 = happySpecReduce_0  18# happyReduction_36
+happyReduction_36  =  happyIn22
+		 (CardEmpty noSpan
+	)
+
+happyReduce_37 = happySpecReduce_1  18# happyReduction_37
+happyReduction_37 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn22
+		 (CardLone ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_38 = happySpecReduce_1  18# happyReduction_38
+happyReduction_38 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn22
+		 (CardSome ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_39 = happySpecReduce_1  18# happyReduction_39
+happyReduction_39 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn22
+		 (CardAny ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_40 = happySpecReduce_1  18# happyReduction_40
+happyReduction_40 happy_x_1
+	 =  case happyOut4 happy_x_1 of { happy_var_1 -> 
+	happyIn22
+		 (CardNum ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_41 = happySpecReduce_1  18# happyReduction_41
+happyReduction_41 happy_x_1
+	 =  case happyOut23 happy_x_1 of { happy_var_1 -> 
+	happyIn22
+		 (CardInterval ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_42 = happySpecReduce_3  19# happyReduction_42
+happyReduction_42 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut4 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut24 happy_x_3 of { happy_var_3 -> 
+	happyIn23
+		 (NCard ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_43 = happySpecReduce_1  20# happyReduction_43
+happyReduction_43 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn24
+		 (ExIntegerAst ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_44 = happySpecReduce_1  20# happyReduction_44
+happyReduction_44 happy_x_1
+	 =  case happyOut4 happy_x_1 of { happy_var_1 -> 
+	happyIn24
+		 (ExIntegerNum ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_45 = happySpecReduce_1  21# happyReduction_45
+happyReduction_45 happy_x_1
+	 =  case happyOut57 happy_x_1 of { happy_var_1 -> 
+	happyIn25
+		 (Path ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_46 = happyReduce 5# 22# happyReduction_46
+happyReduction_46 (happy_x_5 `HappyStk`
+	happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut47 happy_x_3 of { happy_var_3 -> 
+	case happyOutTok happy_x_4 of { happy_var_4 -> 
+	case happyOut26 happy_x_5 of { happy_var_5 -> 
+	happyIn26
+		 (DeclAllDisj ((mkTokenSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_3 happy_var_5
+	) `HappyStk` happyRest}}}}}
+
+happyReduce_47 = happyReduce 4# 22# happyReduction_47
+happyReduction_47 (happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut47 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	case happyOut26 happy_x_4 of { happy_var_4 -> 
+	happyIn26
+		 (DeclAll ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_2 happy_var_4
+	) `HappyStk` happyRest}}}}
+
+happyReduce_48 = happyReduce 5# 22# happyReduction_48
+happyReduction_48 (happy_x_5 `HappyStk`
+	happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOut48 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut47 happy_x_3 of { happy_var_3 -> 
+	case happyOutTok happy_x_4 of { happy_var_4 -> 
+	case happyOut26 happy_x_5 of { happy_var_5 -> 
+	happyIn26
+		 (DeclQuantDisj ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3) >- (mkTokenSpan happy_var_4) >- (mkCatSpan happy_var_5)) happy_var_1 happy_var_3 happy_var_5
+	) `HappyStk` happyRest}}}}}
+
+happyReduce_49 = happyReduce 4# 22# happyReduction_49
+happyReduction_49 (happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOut48 happy_x_1 of { happy_var_1 -> 
+	case happyOut47 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	case happyOut26 happy_x_4 of { happy_var_4 -> 
+	happyIn26
+		 (DeclQuant ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_1 happy_var_2 happy_var_4
+	) `HappyStk` happyRest}}}}
+
+happyReduce_50 = happySpecReduce_1  22# happyReduction_50
+happyReduction_50 happy_x_1
+	 =  case happyOut27 happy_x_1 of { happy_var_1 -> 
+	happyIn26
+		 (happy_var_1
+	)}
+
+happyReduce_51 = happySpecReduce_2  23# happyReduction_51
+happyReduction_51 happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut28 happy_x_2 of { happy_var_2 -> 
+	happyIn27
+		 (EGMax ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+	)}}
+
+happyReduce_52 = happySpecReduce_2  23# happyReduction_52
+happyReduction_52 happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut28 happy_x_2 of { happy_var_2 -> 
+	happyIn27
+		 (EGMin ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+	)}}
+
+happyReduce_53 = happySpecReduce_3  23# happyReduction_53
+happyReduction_53 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut27 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut28 happy_x_3 of { happy_var_3 -> 
+	happyIn27
+		 (EIff ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_54 = happySpecReduce_1  23# happyReduction_54
+happyReduction_54 happy_x_1
+	 =  case happyOut28 happy_x_1 of { happy_var_1 -> 
+	happyIn27
+		 (happy_var_1
+	)}
+
+happyReduce_55 = happySpecReduce_3  24# happyReduction_55
+happyReduction_55 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut28 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut29 happy_x_3 of { happy_var_3 -> 
+	happyIn28
+		 (EImplies ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_56 = happySpecReduce_1  24# happyReduction_56
+happyReduction_56 happy_x_1
+	 =  case happyOut29 happy_x_1 of { happy_var_1 -> 
+	happyIn28
+		 (happy_var_1
+	)}
+
+happyReduce_57 = happySpecReduce_3  25# happyReduction_57
+happyReduction_57 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut29 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut30 happy_x_3 of { happy_var_3 -> 
+	happyIn29
+		 (EOr ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_58 = happySpecReduce_1  25# happyReduction_58
+happyReduction_58 happy_x_1
+	 =  case happyOut30 happy_x_1 of { happy_var_1 -> 
+	happyIn29
+		 (happy_var_1
+	)}
+
+happyReduce_59 = happySpecReduce_3  26# happyReduction_59
+happyReduction_59 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut30 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut31 happy_x_3 of { happy_var_3 -> 
+	happyIn30
+		 (EXor ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_60 = happySpecReduce_1  26# happyReduction_60
+happyReduction_60 happy_x_1
+	 =  case happyOut31 happy_x_1 of { happy_var_1 -> 
+	happyIn30
+		 (happy_var_1
+	)}
+
+happyReduce_61 = happySpecReduce_3  27# happyReduction_61
+happyReduction_61 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut31 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut32 happy_x_3 of { happy_var_3 -> 
+	happyIn31
+		 (EAnd ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_62 = happySpecReduce_1  27# happyReduction_62
+happyReduction_62 happy_x_1
+	 =  case happyOut32 happy_x_1 of { happy_var_1 -> 
+	happyIn31
+		 (happy_var_1
+	)}
+
+happyReduce_63 = happySpecReduce_2  28# happyReduction_63
+happyReduction_63 happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut33 happy_x_2 of { happy_var_2 -> 
+	happyIn32
+		 (ENeg ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+	)}}
+
+happyReduce_64 = happySpecReduce_1  28# happyReduction_64
+happyReduction_64 happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	happyIn32
+		 (happy_var_1
+	)}
+
+happyReduce_65 = happySpecReduce_3  29# happyReduction_65
+happyReduction_65 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (ELt ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_66 = happySpecReduce_3  29# happyReduction_66
+happyReduction_66 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (EGt ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_67 = happySpecReduce_3  29# happyReduction_67
+happyReduction_67 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (EEq ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_68 = happySpecReduce_3  29# happyReduction_68
+happyReduction_68 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (ELte ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_69 = happySpecReduce_3  29# happyReduction_69
+happyReduction_69 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (EGte ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_70 = happySpecReduce_3  29# happyReduction_70
+happyReduction_70 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (ENeq ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_71 = happySpecReduce_3  29# happyReduction_71
+happyReduction_71 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut34 happy_x_3 of { happy_var_3 -> 
+	happyIn33
+		 (EIn ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_72 = happyReduce 4# 29# happyReduction_72
+happyReduction_72 (happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOut33 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	case happyOut34 happy_x_4 of { happy_var_4 -> 
+	happyIn33
+		 (ENin ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4)) happy_var_1 happy_var_4
+	) `HappyStk` happyRest}}}}
+
+happyReduce_73 = happySpecReduce_1  29# happyReduction_73
+happyReduction_73 happy_x_1
+	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
+	happyIn33
+		 (happy_var_1
+	)}
+
+happyReduce_74 = happySpecReduce_2  30# happyReduction_74
+happyReduction_74 happy_x_2
+	happy_x_1
+	 =  case happyOut48 happy_x_1 of { happy_var_1 -> 
+	case happyOut38 happy_x_2 of { happy_var_2 -> 
+	happyIn34
+		 (QuantExp ((mkCatSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_1 happy_var_2
+	)}}
+
+happyReduce_75 = happySpecReduce_1  30# happyReduction_75
+happyReduction_75 happy_x_1
+	 =  case happyOut35 happy_x_1 of { happy_var_1 -> 
+	happyIn34
+		 (happy_var_1
+	)}
+
+happyReduce_76 = happySpecReduce_3  31# happyReduction_76
+happyReduction_76 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut35 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut36 happy_x_3 of { happy_var_3 -> 
+	happyIn35
+		 (EAdd ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_77 = happySpecReduce_3  31# happyReduction_77
+happyReduction_77 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut35 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut36 happy_x_3 of { happy_var_3 -> 
+	happyIn35
+		 (ESub ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_78 = happySpecReduce_1  31# happyReduction_78
+happyReduction_78 happy_x_1
+	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
+	happyIn35
+		 (happy_var_1
+	)}
+
+happyReduce_79 = happySpecReduce_3  32# happyReduction_79
+happyReduction_79 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut37 happy_x_3 of { happy_var_3 -> 
+	happyIn36
+		 (EMul ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_80 = happySpecReduce_3  32# happyReduction_80
+happyReduction_80 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut37 happy_x_3 of { happy_var_3 -> 
+	happyIn36
+		 (EDiv ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_81 = happySpecReduce_1  32# happyReduction_81
+happyReduction_81 happy_x_1
+	 =  case happyOut37 happy_x_1 of { happy_var_1 -> 
+	happyIn36
+		 (happy_var_1
+	)}
+
+happyReduce_82 = happySpecReduce_2  33# happyReduction_82
+happyReduction_82 happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut38 happy_x_2 of { happy_var_2 -> 
+	happyIn37
+		 (ESumSetExp ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+	)}}
+
+happyReduce_83 = happySpecReduce_2  33# happyReduction_83
+happyReduction_83 happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut38 happy_x_2 of { happy_var_2 -> 
+	happyIn37
+		 (ECSetExp ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+	)}}
+
+happyReduce_84 = happySpecReduce_2  33# happyReduction_84
+happyReduction_84 happy_x_2
+	happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut38 happy_x_2 of { happy_var_2 -> 
+	happyIn37
+		 (EMinExp ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2)) happy_var_2
+	)}}
+
+happyReduce_85 = happySpecReduce_1  33# happyReduction_85
+happyReduction_85 happy_x_1
+	 =  case happyOut38 happy_x_1 of { happy_var_1 -> 
+	happyIn37
+		 (happy_var_1
+	)}
+
+happyReduce_86 = happyReduce 6# 34# happyReduction_86
+happyReduction_86 (happy_x_6 `HappyStk`
+	happy_x_5 `HappyStk`
+	happy_x_4 `HappyStk`
+	happy_x_3 `HappyStk`
+	happy_x_2 `HappyStk`
+	happy_x_1 `HappyStk`
+	happyRest)
+	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
+	case happyOut38 happy_x_2 of { happy_var_2 -> 
+	case happyOutTok happy_x_3 of { happy_var_3 -> 
+	case happyOut38 happy_x_4 of { happy_var_4 -> 
+	case happyOutTok happy_x_5 of { happy_var_5 -> 
+	case happyOut39 happy_x_6 of { happy_var_6 -> 
+	happyIn38
+		 (EImpliesElse ((mkTokenSpan happy_var_1) >- (mkCatSpan happy_var_2) >- (mkTokenSpan happy_var_3) >- (mkCatSpan happy_var_4) >- (mkTokenSpan happy_var_5) >- (mkCatSpan happy_var_6)) happy_var_2 happy_var_4 happy_var_6
+	) `HappyStk` happyRest}}}}}}
+
+happyReduce_87 = happySpecReduce_1  34# happyReduction_87
+happyReduction_87 happy_x_1
+	 =  case happyOut39 happy_x_1 of { happy_var_1 -> 
+	happyIn38
+		 (happy_var_1
+	)}
+
+happyReduce_88 = happySpecReduce_1  35# happyReduction_88
+happyReduction_88 happy_x_1
+	 =  case happyOut4 happy_x_1 of { happy_var_1 -> 
+	happyIn39
+		 (EInt ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_89 = happySpecReduce_1  35# happyReduction_89
+happyReduction_89 happy_x_1
+	 =  case happyOut5 happy_x_1 of { happy_var_1 -> 
+	happyIn39
+		 (EDouble ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_90 = happySpecReduce_1  35# happyReduction_90
+happyReduction_90 happy_x_1
+	 =  case happyOut6 happy_x_1 of { happy_var_1 -> 
+	happyIn39
+		 (EStr ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_91 = happySpecReduce_1  35# happyReduction_91
+happyReduction_91 happy_x_1
+	 =  case happyOut40 happy_x_1 of { happy_var_1 -> 
+	happyIn39
+		 (ESetExp ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_92 = happySpecReduce_3  35# happyReduction_92
+happyReduction_92 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut26 happy_x_2 of { happy_var_2 -> 
+	happyIn39
+		 (happy_var_2
+	)}
+
+happyReduce_93 = happySpecReduce_3  36# happyReduction_93
+happyReduction_93 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut40 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut41 happy_x_3 of { happy_var_3 -> 
+	happyIn40
+		 (Union ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_94 = happySpecReduce_3  36# happyReduction_94
+happyReduction_94 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut40 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut41 happy_x_3 of { happy_var_3 -> 
+	happyIn40
+		 (UnionCom ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_95 = happySpecReduce_1  36# happyReduction_95
+happyReduction_95 happy_x_1
+	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
+	happyIn40
+		 (happy_var_1
+	)}
+
+happyReduce_96 = happySpecReduce_3  37# happyReduction_96
+happyReduction_96 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut42 happy_x_3 of { happy_var_3 -> 
+	happyIn41
+		 (Difference ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_97 = happySpecReduce_1  37# happyReduction_97
+happyReduction_97 happy_x_1
+	 =  case happyOut42 happy_x_1 of { happy_var_1 -> 
+	happyIn41
+		 (happy_var_1
+	)}
+
+happyReduce_98 = happySpecReduce_3  38# happyReduction_98
+happyReduction_98 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut42 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut43 happy_x_3 of { happy_var_3 -> 
+	happyIn42
+		 (Intersection ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_99 = happySpecReduce_1  38# happyReduction_99
+happyReduction_99 happy_x_1
+	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
+	happyIn42
+		 (happy_var_1
+	)}
+
+happyReduce_100 = happySpecReduce_3  39# happyReduction_100
+happyReduction_100 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut44 happy_x_3 of { happy_var_3 -> 
+	happyIn43
+		 (Domain ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_101 = happySpecReduce_1  39# happyReduction_101
+happyReduction_101 happy_x_1
+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
+	happyIn43
+		 (happy_var_1
+	)}
+
+happyReduce_102 = happySpecReduce_3  40# happyReduction_102
+happyReduction_102 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut45 happy_x_3 of { happy_var_3 -> 
+	happyIn44
+		 (Range ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_103 = happySpecReduce_1  40# happyReduction_103
+happyReduction_103 happy_x_1
+	 =  case happyOut45 happy_x_1 of { happy_var_1 -> 
+	happyIn44
+		 (happy_var_1
+	)}
+
+happyReduce_104 = happySpecReduce_3  41# happyReduction_104
+happyReduction_104 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut45 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut46 happy_x_3 of { happy_var_3 -> 
+	happyIn45
+		 (Join ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_105 = happySpecReduce_1  41# happyReduction_105
+happyReduction_105 happy_x_1
+	 =  case happyOut46 happy_x_1 of { happy_var_1 -> 
+	happyIn45
+		 (happy_var_1
+	)}
+
+happyReduce_106 = happySpecReduce_1  42# happyReduction_106
+happyReduction_106 happy_x_1
+	 =  case happyOut25 happy_x_1 of { happy_var_1 -> 
+	happyIn46
+		 (ClaferId ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_107 = happySpecReduce_3  42# happyReduction_107
+happyReduction_107 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut40 happy_x_2 of { happy_var_2 -> 
+	happyIn46
+		 (happy_var_2
+	)}
+
+happyReduce_108 = happySpecReduce_3  43# happyReduction_108
+happyReduction_108 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut56 happy_x_1 of { happy_var_1 -> 
+	case happyOutTok happy_x_2 of { happy_var_2 -> 
+	case happyOut40 happy_x_3 of { happy_var_3 -> 
+	happyIn47
+		 (Decl ((mkCatSpan happy_var_1) >- (mkTokenSpan happy_var_2) >- (mkCatSpan happy_var_3)) happy_var_1 happy_var_3
+	)}}}
+
+happyReduce_109 = happySpecReduce_1  44# happyReduction_109
+happyReduction_109 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn48
+		 (QuantNo ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_110 = happySpecReduce_1  44# happyReduction_110
+happyReduction_110 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn48
+		 (QuantNot ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_111 = happySpecReduce_1  44# happyReduction_111
+happyReduction_111 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn48
+		 (QuantLone ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_112 = happySpecReduce_1  44# happyReduction_112
+happyReduction_112 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn48
+		 (QuantOne ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_113 = happySpecReduce_1  44# happyReduction_113
+happyReduction_113 happy_x_1
+	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
+	happyIn48
+		 (QuantSome ((mkTokenSpan happy_var_1))
+	)}
+
+happyReduce_114 = happySpecReduce_1  45# happyReduction_114
+happyReduction_114 happy_x_1
+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> 
+	happyIn49
+		 (EnumIdIdent ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_115 = happySpecReduce_1  46# happyReduction_115
+happyReduction_115 happy_x_1
+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> 
+	happyIn50
+		 (ModIdIdent ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_116 = happySpecReduce_1  47# happyReduction_116
+happyReduction_116 happy_x_1
+	 =  case happyOut7 happy_x_1 of { happy_var_1 -> 
+	happyIn51
+		 (LocIdIdent ((mkCatSpan happy_var_1)) happy_var_1
+	)}
+
+happyReduce_117 = happySpecReduce_0  48# happyReduction_117
+happyReduction_117  =  happyIn52
+		 ([]
+	)
+
+happyReduce_118 = happySpecReduce_2  48# happyReduction_118
+happyReduction_118 happy_x_2
+	happy_x_1
+	 =  case happyOut52 happy_x_1 of { happy_var_1 -> 
+	case happyOut9 happy_x_2 of { happy_var_2 -> 
+	happyIn52
+		 (flip (:)  happy_var_1 happy_var_2
+	)}}
+
+happyReduce_119 = happySpecReduce_1  49# happyReduction_119
+happyReduction_119 happy_x_1
+	 =  case happyOut49 happy_x_1 of { happy_var_1 -> 
+	happyIn53
+		 ((:[])  happy_var_1
+	)}
+
+happyReduce_120 = happySpecReduce_3  49# happyReduction_120
+happyReduction_120 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut49 happy_x_1 of { happy_var_1 -> 
+	case happyOut53 happy_x_3 of { happy_var_3 -> 
+	happyIn53
+		 ((:)  happy_var_1 happy_var_3
+	)}}
+
+happyReduce_121 = happySpecReduce_0  50# happyReduction_121
+happyReduction_121  =  happyIn54
+		 ([]
+	)
+
+happyReduce_122 = happySpecReduce_2  50# happyReduction_122
+happyReduction_122 happy_x_2
+	happy_x_1
+	 =  case happyOut54 happy_x_1 of { happy_var_1 -> 
+	case happyOut16 happy_x_2 of { happy_var_2 -> 
+	happyIn54
+		 (flip (:)  happy_var_1 happy_var_2
+	)}}
+
+happyReduce_123 = happySpecReduce_0  51# happyReduction_123
+happyReduction_123  =  happyIn55
+		 ([]
+	)
+
+happyReduce_124 = happySpecReduce_2  51# happyReduction_124
+happyReduction_124 happy_x_2
+	happy_x_1
+	 =  case happyOut55 happy_x_1 of { happy_var_1 -> 
+	case happyOut26 happy_x_2 of { happy_var_2 -> 
+	happyIn55
+		 (flip (:)  happy_var_1 happy_var_2
+	)}}
+
+happyReduce_125 = happySpecReduce_1  52# happyReduction_125
+happyReduction_125 happy_x_1
+	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
+	happyIn56
+		 ((:[])  happy_var_1
+	)}
+
+happyReduce_126 = happySpecReduce_3  52# happyReduction_126
+happyReduction_126 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
+	case happyOut56 happy_x_3 of { happy_var_3 -> 
+	happyIn56
+		 ((:)  happy_var_1 happy_var_3
+	)}}
+
+happyReduce_127 = happySpecReduce_1  53# happyReduction_127
+happyReduction_127 happy_x_1
+	 =  case happyOut50 happy_x_1 of { happy_var_1 -> 
+	happyIn57
+		 ((:[])  happy_var_1
+	)}
+
+happyReduce_128 = happySpecReduce_3  53# happyReduction_128
+happyReduction_128 happy_x_3
+	happy_x_2
+	happy_x_1
+	 =  case happyOut50 happy_x_1 of { happy_var_1 -> 
+	case happyOut57 happy_x_3 of { happy_var_3 -> 
+	happyIn57
+		 ((:)  happy_var_1 happy_var_3
+	)}}
+
+happyNewToken action sts stk [] =
+	happyDoAction 67# notHappyAtAll action sts stk []
+
+happyNewToken action sts stk (tk:tks) =
+	let cont i = happyDoAction i tk action sts stk tks in
+	case tk of {
+	PT _ (TS _ 1) -> cont 1#;
+	PT _ (TS _ 2) -> cont 2#;
+	PT _ (TS _ 3) -> cont 3#;
+	PT _ (TS _ 4) -> cont 4#;
+	PT _ (TS _ 5) -> cont 5#;
+	PT _ (TS _ 6) -> cont 6#;
+	PT _ (TS _ 7) -> cont 7#;
+	PT _ (TS _ 8) -> cont 8#;
+	PT _ (TS _ 9) -> cont 9#;
+	PT _ (TS _ 10) -> cont 10#;
+	PT _ (TS _ 11) -> cont 11#;
+	PT _ (TS _ 12) -> cont 12#;
+	PT _ (TS _ 13) -> cont 13#;
+	PT _ (TS _ 14) -> cont 14#;
+	PT _ (TS _ 15) -> cont 15#;
+	PT _ (TS _ 16) -> cont 16#;
+	PT _ (TS _ 17) -> cont 17#;
+	PT _ (TS _ 18) -> cont 18#;
+	PT _ (TS _ 19) -> cont 19#;
+	PT _ (TS _ 20) -> cont 20#;
+	PT _ (TS _ 21) -> cont 21#;
+	PT _ (TS _ 22) -> cont 22#;
+	PT _ (TS _ 23) -> cont 23#;
+	PT _ (TS _ 24) -> cont 24#;
+	PT _ (TS _ 25) -> cont 25#;
+	PT _ (TS _ 26) -> cont 26#;
+	PT _ (TS _ 27) -> cont 27#;
+	PT _ (TS _ 28) -> cont 28#;
+	PT _ (TS _ 29) -> cont 29#;
+	PT _ (TS _ 30) -> cont 30#;
+	PT _ (TS _ 31) -> cont 31#;
+	PT _ (TS _ 32) -> cont 32#;
+	PT _ (TS _ 33) -> cont 33#;
+	PT _ (TS _ 34) -> cont 34#;
+	PT _ (TS _ 35) -> cont 35#;
+	PT _ (TS _ 36) -> cont 36#;
+	PT _ (TS _ 37) -> cont 37#;
+	PT _ (TS _ 38) -> cont 38#;
+	PT _ (TS _ 39) -> cont 39#;
+	PT _ (TS _ 40) -> cont 40#;
+	PT _ (TS _ 41) -> cont 41#;
+	PT _ (TS _ 42) -> cont 42#;
+	PT _ (TS _ 43) -> cont 43#;
+	PT _ (TS _ 44) -> cont 44#;
+	PT _ (TS _ 45) -> cont 45#;
+	PT _ (TS _ 46) -> cont 46#;
+	PT _ (TS _ 47) -> cont 47#;
+	PT _ (TS _ 48) -> cont 48#;
+	PT _ (TS _ 49) -> cont 49#;
+	PT _ (TS _ 50) -> cont 50#;
+	PT _ (TS _ 51) -> cont 51#;
+	PT _ (TS _ 52) -> cont 52#;
+	PT _ (TS _ 53) -> cont 53#;
+	PT _ (TS _ 54) -> cont 54#;
+	PT _ (TS _ 55) -> cont 55#;
+	PT _ (TS _ 56) -> cont 56#;
+	PT _ (TS _ 57) -> cont 57#;
+	PT _ (TS _ 58) -> cont 58#;
+	PT _ (TS _ 59) -> cont 59#;
+	PT _ (TS _ 60) -> cont 60#;
+	PT _ (TS _ 61) -> cont 61#;
+	PT _ (T_PosInteger _) -> cont 62#;
+	PT _ (T_PosDouble _) -> cont 63#;
+	PT _ (T_PosString _) -> cont 64#;
+	PT _ (T_PosIdent _) -> cont 65#;
+	_ -> cont 66#;
+	_ -> happyError' (tk:tks)
+	}
+
+happyError_ 67# tk tks = happyError' tks
+happyError_ _ tk tks = happyError' (tk:tks)
+
+happyThen :: () => Err a -> (a -> Err b) -> Err b
+happyThen = (thenM)
+happyReturn :: () => a -> Err a
+happyReturn = (returnM)
+happyThen1 m k tks = (thenM) m (\a -> k a tks)
+happyReturn1 :: () => a -> b -> Err a
+happyReturn1 = \a tks -> (returnM) a
+happyError' :: () => [(Token)] -> Err a
+happyError' = happyError
+
+pModule tks = happySomeParser where
+  happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut8 x))
+
+happySeq = happyDontSeq
+
+
+returnM :: a -> Err a
+returnM = return
+
+thenM :: Err a -> (a -> Err b) -> Err b
+thenM = (>>=)
+
+happyError :: [Token] -> Err a
+happyError ts =
+  Bad (pp ts) $
+  case ts of
+    [] -> []
+    [Err _] -> " due to lexer error"
+    _ -> "before " ++ unwords (map (id . prToken) (take 4 ts))
+
+gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
+pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
+pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
+pp _ = error "EOF"
+
+mkCatSpan :: (Spannable c) => c -> Span
+mkCatSpan = getSpan
+
+mkTokenSpan :: Token -> Span
+mkTokenSpan = gp
+myLexer = tokens
+{-# LINE 1 "templates\GenericTemplate.hs" #-}
+{-# LINE 1 "templates\\GenericTemplate.hs" #-}
+{-# LINE 1 "<built-in>" #-}
+{-# LINE 1 "<command-line>" #-}
+{-# LINE 1 "templates\\GenericTemplate.hs" #-}
+-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp 
+
+{-# LINE 13 "templates\\GenericTemplate.hs" #-}
+
+
+
+
+
+-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
+#if __GLASGOW_HASKELL__ > 706
+#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool)
+#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool)
+#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool)
+#else
+#define LT(n,m) (n Happy_GHC_Exts.<# m)
+#define GTE(n,m) (n Happy_GHC_Exts.>=# m)
+#define EQ(n,m) (n Happy_GHC_Exts.==# m)
+#endif
+{-# LINE 46 "templates\\GenericTemplate.hs" #-}
+
+
+data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList
+
+
+
+
+
+{-# LINE 67 "templates\\GenericTemplate.hs" #-}
+
+{-# LINE 77 "templates\\GenericTemplate.hs" #-}
+
+{-# LINE 86 "templates\\GenericTemplate.hs" #-}
+
+infixr 9 `HappyStk`
+data HappyStk a = HappyStk a (HappyStk a)
+
+-----------------------------------------------------------------------------
+-- starting the parse
+
+happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
+
+-----------------------------------------------------------------------------
+-- Accepting the parse
+
+-- If the current token is 0#, it means we've just accepted a partial
+-- parse (a %partial parser).  We must ignore the saved token on the top of
+-- the stack in this case.
+happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =
+        happyReturn1 ans
+happyAccept j tk st sts (HappyStk ans _) = 
+        (happyTcHack j (happyTcHack st)) (happyReturn1 ans)
+
+-----------------------------------------------------------------------------
+-- Arrays only: do the next action
+
+
+
+happyDoAction i tk st
+        = {- nothing -}
+
+
+          case action of
+                0#           -> {- nothing -}
+                                     happyFail i tk st
+                -1#          -> {- nothing -}
+                                     happyAccept i tk st
+                n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}
+
+                                                   (happyReduceArr Happy_Data_Array.! rule) i tk st
+                                                   where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
+                n                 -> {- nothing -}
+
+
+                                     happyShift new_state i tk st
+                                     where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
+   where off    = indexShortOffAddr happyActOffsets st
+         off_i  = (off Happy_GHC_Exts.+# i)
+         check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))
+                  then EQ(indexShortOffAddr happyCheck off_i, i)
+                  else False
+         action
+          | check     = indexShortOffAddr happyTable off_i
+          | otherwise = indexShortOffAddr happyDefActions st
+
+
+indexShortOffAddr (HappyA# arr) off =
+        Happy_GHC_Exts.narrow16Int# i
+  where
+        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
+        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
+        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
+        off' = off Happy_GHC_Exts.*# 2#
+
+
+
+
+
+data HappyAddr = HappyA# Happy_GHC_Exts.Addr#
+
+
+
+
+-----------------------------------------------------------------------------
+-- HappyState data type (not arrays)
+
+{-# LINE 170 "templates\\GenericTemplate.hs" #-}
+
+-----------------------------------------------------------------------------
+-- Shifting a token
+
+happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
+     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
+--     trace "shifting the error token" $
+     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)
+
+happyShift new_state i tk st sts stk =
+     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)
+
+-- happyReduce is specialised for the common cases.
+
+happySpecReduce_0 i fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happySpecReduce_0 nt fn j tk st@((action)) sts stk
+     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)
+
+happySpecReduce_1 i fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
+     = let r = fn v1 in
+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
+
+happySpecReduce_2 i fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
+     = let r = fn v1 v2 in
+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
+
+happySpecReduce_3 i fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
+     = let r = fn v1 v2 v3 in
+       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
+
+happyReduce k i fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happyReduce k nt fn j tk st sts stk
+     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
+         sts1@((HappyCons (st1@(action)) (_))) ->
+                let r = fn stk in  -- it doesn't hurt to always seq here...
+                happyDoSeq r (happyGoto nt j tk st1 sts1 r)
+
+happyMonadReduce k nt fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happyMonadReduce k nt fn j tk st sts stk =
+      case happyDrop k (HappyCons (st) (sts)) of
+        sts1@((HappyCons (st1@(action)) (_))) ->
+          let drop_stk = happyDropStk k stk in
+          happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))
+
+happyMonad2Reduce k nt fn 0# tk st sts stk
+     = happyFail 0# tk st sts stk
+happyMonad2Reduce k nt fn j tk st sts stk =
+      case happyDrop k (HappyCons (st) (sts)) of
+        sts1@((HappyCons (st1@(action)) (_))) ->
+         let drop_stk = happyDropStk k stk
+
+             off = indexShortOffAddr happyGotoOffsets st1
+             off_i = (off Happy_GHC_Exts.+# nt)
+             new_state = indexShortOffAddr happyTable off_i
+
+
+
+          in
+          happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
+
+happyDrop 0# l = l
+happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t
+
+happyDropStk 0# l = l
+happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs
+
+-----------------------------------------------------------------------------
+-- Moving to a new state after a reduction
+
+
+happyGoto nt j tk st = 
+   {- nothing -}
+   happyDoAction j tk new_state
+   where off = indexShortOffAddr happyGotoOffsets st
+         off_i = (off Happy_GHC_Exts.+# nt)
+         new_state = indexShortOffAddr happyTable off_i
+
+
+
+
+-----------------------------------------------------------------------------
+-- Error recovery (0# is the error token)
+
+-- parse error if we are in recovery and we fail again
+happyFail 0# tk old_st _ stk@(x `HappyStk` _) =
+     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
+--      trace "failing" $ 
+        happyError_ i tk
+
+{-  We don't need state discarding for our restricted implementation of
+    "error".  In fact, it can cause some bogus parses, so I've disabled it
+    for now --SDM
+
+-- discard a state
+happyFail  0# tk old_st (HappyCons ((action)) (sts)) 
+                                                (saved_tok `HappyStk` _ `HappyStk` stk) =
+--      trace ("discarding state, depth " ++ show (length stk))  $
+        happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))
+-}
+
+-- Enter error recovery: generate an error token,
+--                       save the old token and carry on.
+happyFail  i tk (action) sts stk =
+--      trace "entering error recovery" $
+        happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)
+
+-- Internal happy errors:
+
+notHappyAtAll :: a
+notHappyAtAll = error "Internal Happy error\n"
+
+-----------------------------------------------------------------------------
+-- Hack to get the typechecker to accept our action functions
+
+
+happyTcHack :: Happy_GHC_Exts.Int# -> a -> a
+happyTcHack x y = y
+{-# INLINE happyTcHack #-}
+
+
+-----------------------------------------------------------------------------
+-- Seq-ing.  If the --strict flag is given, then Happy emits 
+--      happySeq = happyDoSeq
+-- otherwise it emits
+--      happySeq = happyDontSeq
+
+happyDoSeq, happyDontSeq :: a -> b -> b
+happyDoSeq   a b = a `seq` b
+happyDontSeq a b = b
+
+-----------------------------------------------------------------------------
+-- Don't inline any functions from the template.  GHC has a nasty habit
+-- of deciding to inline happyGoto everywhere, which increases the size of
+-- the generated parser quite a bit.
+
+
+{-# NOINLINE happyDoAction #-}
+{-# NOINLINE happyTable #-}
+{-# NOINLINE happyCheck #-}
+{-# NOINLINE happyActOffsets #-}
+{-# NOINLINE happyGotoOffsets #-}
+{-# NOINLINE happyDefActions #-}
+
+{-# NOINLINE happyShift #-}
+{-# NOINLINE happySpecReduce_0 #-}
+{-# NOINLINE happySpecReduce_1 #-}
+{-# NOINLINE happySpecReduce_2 #-}
+{-# NOINLINE happySpecReduce_3 #-}
+{-# NOINLINE happyReduce #-}
+{-# NOINLINE happyMonadReduce #-}
+{-# NOINLINE happyGoto #-}
+{-# NOINLINE happyFail #-}
+
+-- end of Happy Template.
+ src-cmd/clafer.hs view
@@ -0,0 +1,216 @@+{-
+ Copyright (C) 2012-2014 Kacper Bak, Jimmy Liang, Michal Antkiewicz <http://gsd.uwaterloo.ca>
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+ of the Software, and to permit persons to whom the Software is furnished to do
+ so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+-}
+{-# LANGUAGE DeriveDataTypeable, NamedFieldPuns #-}
+module Main where
+
+import Prelude hiding (writeFile, readFile, print, putStrLn)
+import qualified Data.Map as Map
+import qualified Data.List as List
+import Data.List.Split
+import Data.Maybe
+import Control.Monad.State
+import System.IO
+import System.Process
+import System.Exit
+import System.Timeout
+import System.FilePath (dropExtension,takeBaseName)
+import System.Process (readProcessWithExitCode)
+
+import Paths_clafer
+import Language.Clafer
+import Language.ClaferT
+import Language.Clafer.Css
+import Language.Clafer.ClaferArgs
+import Language.Clafer.JSONMetaData
+import Language.Clafer.QNameUID
+import Language.Clafer.Intermediate.Intclafer
+import Language.Clafer.Generator.Html (highlightErrors)
+import Language.Clafer.Generator.Graph (genSimpleGraph)
+
+putStrV :: VerbosityL -> String -> IO ()
+putStrV v s = if v > 1 then putStrLn s else return ()
+
+run :: VerbosityL -> ClaferArgs -> InputModel -> IO ()
+run _ args' input =
+  do
+    result <- runClaferT args' $
+      do
+        addFragments $ fragments input
+        parse
+        compile
+        fs <- save args'
+        when (validate args') $ forM_ fs (liftIO . runValidate args' )
+    if Html `elem` (mode args')
+      then htmlCatch result args' input
+      else return ()
+    result `cth` handleErrs
+  where
+  cth (Left err) f = f err
+  cth (Right r)  _ = return r
+  addFragments []     = return ()
+  addFragments (x:xs) = addModuleFragment x >> addFragments xs
+  fragments model = map unlines $ fragments' $ lines model
+  fragments' []                  = []
+  fragments' ("//# FRAGMENT":xs) = fragments' xs
+  fragments' model               = takeWhile (/= "//# FRAGMENT") model : fragments' (dropWhile (/= "//# FRAGMENT") model)
+--  htmlCatch :: Either ClaferErr CompilerResult -> ClaferArgs -> String -> IO(CompilerResult)
+  htmlCatch (Right r) _ _ = return r
+  htmlCatch (Left err) args'' model =
+    do let f = (dropExtension $ file args'') ++ ".html"
+       let result = (if (self_contained args'') then header ++ "<style>" ++ css ++ "</style>" ++ "</head>\n<body>\n<pre>\n" else "") ++ highlightErrors model err ++
+                                                               (if (self_contained args'') then "\n</pre>\n</html>" else "")
+       liftIO $ if console_output args'' then putStrLn result else writeFile f result
+  
+  handleErrs = mapM_ handleErr
+  
+  handleErr (ClaferErr mesg) =
+    do
+      putStrLn "\nError...\n"
+      putStrLn mesg
+      exitFailure
+  -- We only use one fragment. Fragment id and position is not useful to us. We
+  -- only care about the position relative to 
+  handleErr (ParseErr ErrPos{modelPos = Pos l c} mesg) =
+    do
+      putStrLn $ "\nParse failed at line " ++ show l ++ " column " ++ show c ++ "..."
+      putStrLn mesg
+      exitFailure
+  handleErr (SemanticErr ErrPos{modelPos = Pos l c} mesg) =
+    do
+      putStrLn $ "\nCompile error at line " ++ show l ++ " column " ++ show c ++ "..."
+      putStrLn mesg
+      exitFailure
+
+save :: MonadIO m => ClaferArgs -> ClaferT m [ String ]
+save args'=
+  do
+    resultsMap <- generate
+    let results = snd $ List.unzip $ Map.toList resultsMap
+    -- print stats only once
+    when (not $ no_stats args') $ liftIO $ printStats results
+    -- save the outputs
+    (iModule, _, _) <- getIr
+    forM results $ saveResult iModule resultsMap
+  where
+    -- saveResult :: MonadIO m => CompilerResult -> IModule -> (Map.Map ClaferMode CompilerResult) -> ClaferT m String
+    saveResult iModule' resultsMap' result@CompilerResult { extension } = do
+      result' <- if (add_graph args') && (Html `elem` (mode args') && ("dot" `List.isSuffixOf` (extension))) 
+            then do
+                   ast' <- getAst
+                   (_, graph, _) <- liftIO $ readProcessWithExitCode "dot"  ["-Tsvg"] $ genSimpleGraph ast' iModule' (takeBaseName $ file args') (show_references args')
+                   return $ summary graph result
+            else return result
+      let f = dropExtension $ file args'
+      let f' = f ++ "." ++ extension
+      liftIO $ if console_output args' then putStrLn (outputCode result') else writeFile f' (outputCode result')
+      liftIO $ when (alloy_mapping args') $ writeFile (f ++ ".map") $ show (mappingToAlloy result')
+      let 
+        qNameMaps :: QNameMaps
+        qNameMaps = deriveQNameMaps iModule'
+      liftIO $ when (meta_data args') $ writeFile (f ++ ".cfr-map") $ generateJSONnameUIDMap qNameMaps
+      liftIO $ when (meta_data args' && inScopeModes) $ writeFile (f ++ ".cfr-scope") $ generateJSONScopes qNameMaps $ getScopesList resultsMap'
+      return f'  
+    saveResult _ _ NoCompilerResult { reason } = do 
+      liftIO $ putStrLn reason
+      return ""
+    printStats :: [CompilerResult] -> IO ()
+    printStats []         = putStrLn "No compiler output."
+    printStats (r:rs) = case r of
+      CompilerResult { statistics } -> putStrLn statistics
+      (NoCompilerResult _) -> printStats rs
+
+    inScopeModes :: Bool
+    inScopeModes = 
+      Alloy `elem` mode args' ||
+      Alloy42 `elem` mode args' ||
+      Choco `elem` mode args'
+
+    getScopesList :: (Map.Map ClaferMode CompilerResult) -> [(UID, Integer)]
+    getScopesList    resultsMap =
+        let
+           alloyResult = Map.lookup Alloy resultsMap
+           alloy42Result = Map.lookup Alloy42 resultsMap
+           chocoResult = Map.lookup Choco resultsMap
+        in 
+           if (isNothing alloyResult)
+           then if (isNothing alloy42Result)
+                then if (isNothing chocoResult)
+                     then []
+                     else scopesList $ fromJust chocoResult
+                else scopesList $ fromJust alloy42Result
+           else scopesList $ fromJust alloyResult
+
+summary :: String -> CompilerResult -> CompilerResult
+summary graph result = result{outputCode=unlines $ summary' graph ("<pre>" ++ statistics result ++ "</pre>") (lines $ outputCode result)}
+
+summary' :: String -> String -> [String] -> [String]
+summary' _ _ [] = []
+summary' graph stats ("<!-- # SUMMARY /-->":xs) = graph:stats:summary' graph stats xs
+summary' graph stats ("<!-- # STATS /-->":xs) = stats:summary' graph stats xs
+summary' graph stats ("<!-- # GRAPH /-->":xs) = graph:summary' graph stats xs
+summary' graph stats ("<!-- # CVLGRAPH /-->":xs) = graph:summary' graph stats xs
+summary' graph stats (x:xs) = x:summary' graph stats xs
+
+conPutStrLn :: ClaferArgs -> String -> IO ()
+conPutStrLn args' s = when (not $ console_output args') $ putStrLn s
+
+runValidate :: ClaferArgs -> String -> IO ()
+runValidate args' fo = do
+  let path = (tooldir args') ++ "/"
+  liftIO $ putStrLn ("Validating '" ++ fo ++"'")
+  let modes = mode args' 
+  when (Xml `elem` modes && "xml" `List.isSuffixOf` fo) $ do
+      writeFile "ClaferIR.xsd" claferIRXSD
+      voidf $ system $ "java -classpath " ++ path ++ " XsdCheck ClaferIR.xsd " ++ fo
+  when (Alloy `elem` modes && "als41" `List.isSuffixOf` fo) $ do
+    voidf $ system $ validateAlloy path "4" ++ fo
+  when (Alloy42 `elem` modes && "als" `List.isSuffixOf` fo) $ do
+    voidf $ system $ validateAlloy path "4.2" ++ fo
+  when (Clafer `elem` modes && "des.cfr" `List.isSuffixOf` fo) $ do  
+    voidf $ system $ "../dist/build/clafer/clafer -s -m=clafer " ++ fo
+
+validateAlloy :: String -> String -> String
+validateAlloy path version = "java -cp " ++ path ++ "alloy" ++ version ++ ".jar edu.mit.csail.sdg.alloy4whole.ExampleUsingTheCompiler "
+
+main :: IO ()
+main = do
+  (args', model) <- mainArgs
+  let timeInSec = (timeout_analysis args') * 10^(6::Integer)
+  if timeInSec > 0
+    then timeout timeInSec $ start 2 args' model
+    else Just `liftM` start 2 args' model
+  return ()
+
+start :: VerbosityL -> ClaferArgs -> InputModel-> IO ()
+start v args' model = if schema args'
+  then putStrLn claferIRXSD
+  else if ecore2clafer args'
+    then runEcore2Clafer (file args') $ (tooldir args')
+    else run v args' model
+
+runEcore2Clafer :: FilePath -> FilePath -> IO ()
+runEcore2Clafer    ecoreFile toolPath
+  | null ecoreFile = do
+      putStrLn "Error: Provide a file name of an ECore model."
+  | otherwise      = do
+      putStrLn $ "Converting " ++ ecoreFile ++ " into Clafer"
+      voidf $ system $ "java -jar " ++ toolPath ++ "/ecore2clafer.jar " ++ ecoreFile
src/Language/Clafer.hs view
@@ -93,12 +93,14 @@                         module Language.Clafer.Front.ErrM)
 where
 
+import Data.Data.Lens
 import Data.Either
 import Data.List
 import Data.Maybe
 import qualified Data.Map as Map
 import Data.Ord
 import Control.Monad
+import Control.Lens.Plated
 import System.FilePath (takeBaseName)
 
 import Language.ClaferT 
@@ -113,7 +115,6 @@ import Language.Clafer.Front.Printclafer
 import Language.Clafer.Front.Absclafer 
 import Language.Clafer.Front.LayoutResolver
-import Language.Clafer.Front.Mapper
 import Language.Clafer.Intermediate.Tracing
 import Language.Clafer.Intermediate.Intclafer
 import Language.Clafer.Intermediate.Desugarer
@@ -208,7 +209,7 @@     --
     -- The second one is easier so that's we'll do for now. There shouldn't be any errors since
     -- each individual fragment already passed.
-    ast' <- case asts of
+    ast <- case asts of
       -- Special case: if there is only one fragment, then the complete model is contained within it.
       -- Don't need to reparse. This is the common case.
       [oneFrag] -> return oneFrag
@@ -218,8 +219,6 @@         completeAst <- (parseFrag $ args env) completeModel
         liftParseErr completeAst
 
-    
-    let ast = mapModule ast'
     let env' = env{ cAst = Just ast, astModuleTrace = traceAstModule ast }
     putEnv env'
   where
@@ -259,15 +258,9 @@     where
       isKeyWord :: Ir -> String
       isKeyWord (IRClafer IClafer{_cinPos = (Span (Pos l c) _) ,_ident=i}) = if (i `elem` keyWords) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
-      isKeyWord (IRClafer IClafer{_cinPos = (PosSpan _ (Pos l c) _) ,_ident=i}) = if (i `elem` keyWords) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
-      isKeyWord (IRClafer IClafer{_cinPos = (Span (PosPos _ l c) _) ,_ident=i}) = if (i `elem` keyWords) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
-      isKeyWord (IRClafer IClafer{_cinPos = (PosSpan _ (PosPos _ l c) _) ,_ident=i}) = if (i `elem` keyWords) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
       isKeyWord _ = ""
       gt1 :: Ir -> String
       gt1 (IRClafer (IClafer (Span (Pos l c) _) False _ _ _ _ (Just (_, m)) _ _)) = if (m > 1 || m < 0) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
-      gt1 (IRClafer (IClafer (Span (PosPos _ l c) _) False _ _ _ _ (Just (_, m)) _ _)) = if (m > 1 || m < 0) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else "" 
-      gt1 (IRClafer (IClafer (PosSpan _ (Pos l c) _) False _ _ _ _ (Just (_, m)) _ _)) = if (m > 1 || m < 0) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
-      gt1 (IRClafer (IClafer (PosSpan _ (PosPos _ l c) _) False _ _ _ _ (Just (_, m)) _ _)) = if (m > 1 || m < 0) then ("Line " ++ show l ++ " column " ++ show c ++ "\n") else ""
       gt1 _ = ""
 
 -- | Splits the IR into their fragments, and generates the output for each fragment.
@@ -301,7 +294,6 @@   beforePos ele p =
     case rnge ele of
       Span _ e -> e <= p
-      PosSpan _ _ e -> e <= p
   generateFragment :: ClaferArgs -> [IElement] -> String
   generateFragment args' frag =
     flatten $ cconcat $ map (genDeclaration args') frag
@@ -309,7 +301,7 @@ -- | Splits the AST into their fragments, and generates the output for each fragment.
 generateHtml :: ClaferEnv -> Module -> String
 generateHtml env ast' =
-    let PosModule _ decls' = ast';
+    let Module _ decls' = ast';
         cargs = args env;
         irMap = irModuleTrace env;
         comments = if add_comments cargs then getComments $ unlines $ modelFrags env else [];
@@ -318,28 +310,33 @@        (if (self_contained cargs) then "</body>\n</html>" else "")
 
   where
-    lne (PosElementDecl (Span p _) _) = p
-    lne (PosEnumDecl (Span p _) _  _) = p
-    lne _                               = Pos 0 0
+    lne :: Declaration -> Pos
+    lne (ElementDecl (Span p _) _) = p
+    lne (EnumDecl (Span p _) _  _) = p
     genFragments :: [Declaration] -> [Pos] -> Map.Map Span [Ir] -> [(Span, String)] -> [String]
     genFragments []           _            _     comments = printComments comments
-    genFragments (decl:decls') []           irMap comments = let (comments', c) = printPreComment (range decl) comments in
+    genFragments (decl:decls') []           irMap comments = let (comments', c) = printPreComment (getSpan decl) comments in
                                                                    [c] ++ (cleanOutput $ revertLayout $ printDeclaration decl 0 irMap True $ inDecl decl comments') : (genFragments decls' [] irMap $ afterDecl decl comments)
     genFragments (decl:decls') (frg:frgs) irMap comments = if lne decl < frg
-                                                                 then let (comments', c) = printPreComment (range decl) comments in
+                                                                 then let (comments', c) = printPreComment (getSpan decl) comments in
                                                                    [c] ++ (cleanOutput $ revertLayout $ printDeclaration decl 0 irMap True $ inDecl decl comments') : (genFragments decls' (frg:frgs) irMap $ afterDecl decl comments)
                                                                  else "<!-- # FRAGMENT /-->" : genFragments (decl:decls') frgs irMap comments
     inDecl :: Declaration -> [(Span, String)] -> [(Span, String)]
-    inDecl decl comments = let s = rnge decl in dropWhile (\x -> fst x < s) comments
+    inDecl decl comments = let s = getSpan decl in dropWhile (\x -> fst x < s) comments
     afterDecl :: Declaration -> [(Span, String)] -> [(Span, String)]
-    afterDecl decl comments = let (Span _ (Pos line' _)) = rnge decl in dropWhile (\(x, _) -> let (Span _ (Pos line'' _)) = x in line'' <= line') comments
-    rnge (EnumDecl _ _) = noSpan
-    rnge (PosEnumDecl s _ _) = s
-    rnge (ElementDecl _) = noSpan
-    rnge (PosElementDecl s _) = s
+    afterDecl decl comments = let (Span _ (Pos line' _)) = getSpan decl in dropWhile (\(x, _) -> let (Span _ (Pos line'' _)) = x in line'' <= line') comments
     printComments [] = []
     printComments ((s, comment):cs) = (snd (printComment s [(s, comment)]) ++ "<br>\n"):printComments cs
 
+noReals :: IModule -> Bool
+noReals iModule = reals == []
+  where 
+    iexps :: [ IExp ]
+    iexps = universeOn biplate iModule
+    reals = filter isIDouble iexps
+    isIDouble (IDouble _) = True
+    isIDouble _           = False
+
 -- | Generates outputs for the given IR.
 generate :: Monad m => ClaferT m (Map.Map ClaferMode CompilerResult)
 generate =
@@ -348,50 +345,66 @@     ast' <- getAst
     (iModule, genv, au) <- getIr
     let 
+      hasNoReals = noReals iModule
       cargs = args env
-      stats = showStats au $ statsModule iModule
       modes = mode cargs
+      stats = showStats au $ statsModule iModule
       scopes = getScopeStrategy (scope_strategy cargs) iModule
+
     return $ Map.fromList ( 
         -- result for Alloy
         (if (Alloy `elem` modes)
-          then let 
-                  (imod,strMap) = astrModule iModule
-                  alloyCode = genModule cargs{mode = [Alloy]} (imod, genv) scopes
-                  addCommentStats = if no_stats cargs then const else addStats 
-               in 
-                  [ (Alloy, 
-                    CompilerResult { 
-                     extension = "als", 
-                     outputCode = addCommentStats (fst alloyCode) stats, 
-                     statistics = stats,
-                     claferEnv  = env,
-                     mappingToAlloy = fromMaybe [] (Just $ snd alloyCode),
-                     stringMap = strMap,
-                     scopesList = scopes
-                    })
-                  ]
+          then if (hasNoReals)
+                then 
+                  let 
+                    (imod,strMap) = astrModule iModule
+                    alloyCode = genModule cargs{mode = [Alloy]} (imod, genv) scopes
+                    addCommentStats = if no_stats cargs then const else addStats 
+                  in 
+                    [ (Alloy, 
+                      CompilerResult { 
+                       extension = "als41", 
+                       outputCode = addCommentStats (fst alloyCode) stats, 
+                       statistics = stats,
+                       claferEnv  = env,
+                       mappingToAlloy = fromMaybe [] (Just $ snd alloyCode),
+                       stringMap = strMap,
+                       scopesList = scopes
+                      })
+                    ]
+                else [ (Alloy, 
+                        NoCompilerResult { 
+                         reason = "Alloy output unavailable because the model contains real numbers." 
+                        })
+                     ]
           else []
         ) 
         ++
         -- result for Alloy42
         (if (Alloy42 `elem` modes)
-          then let 
-                  (imod,strMap) = astrModule iModule
-                  alloyCode = genModule cargs{mode = [Alloy42]} (imod, genv) scopes
-                  addCommentStats = if no_stats cargs then const else addStats 
-               in 
-                  [ (Alloy42, 
-                    CompilerResult { 
-                     extension = "als4", 
-                     outputCode = addCommentStats (fst alloyCode) stats, 
-                     statistics = stats,
-                     claferEnv  = env,
-                     mappingToAlloy = fromMaybe [] (Just $ snd alloyCode),
-                     stringMap = strMap,
-                     scopesList = scopes
-                    })
-                  ]
+          then if (hasNoReals)
+                then
+                   let 
+                      (imod,strMap) = astrModule iModule
+                      alloyCode = genModule cargs{mode = [Alloy42]} (imod, genv) scopes
+                      addCommentStats = if no_stats cargs then const else addStats 
+                   in 
+                      [ (Alloy42, 
+                        CompilerResult { 
+                         extension = "als", 
+                         outputCode = addCommentStats (fst alloyCode) stats, 
+                         statistics = stats,
+                         claferEnv  = env,
+                         mappingToAlloy = fromMaybe [] (Just $ snd alloyCode),
+                         stringMap = strMap,
+                         scopesList = scopes
+                        })
+                      ]
+                else [ (Alloy, 
+                        NoCompilerResult { 
+                         reason = "Alloy output unavailable because the model contains real numbers." 
+                        })
+                     ]
           else []
         )   
         -- result for XML    
@@ -509,7 +522,10 @@                             stringMap :: (Map.Map Int String),
                             -- | scopes generated by scope inference
                             scopesList :: [(UID, Integer)]
-                            } deriving Show
+                            } 
+                      | NoCompilerResult {
+                            reason :: String
+                      } deriving Show
 
 desugar :: Module -> IModule  
 desugar iModule = desugarModule iModule
@@ -532,10 +548,11 @@ 
 showStats :: Bool -> Stats -> String
 showStats au (Stats na nr nc nconst ngoals sgl) =
-  unlines [ "All clafers: " ++ (show (na + nr + nc)) ++ " | Abstract: " ++ (show na) ++ " | Concrete: " ++ (show nc) ++ " | References: " ++ (show nr)          , "Constraints: " ++ show nconst
+  unlines [ "All clafers: " ++ (show (na + nr + nc)) ++ " | Abstract: " ++ (show na) ++ " | Concrete: " ++ (show nc) ++ " | References: " ++ (show nr)
+          , "Constraints: " ++ show nconst
           , "Goals: " ++ show ngoals  
           , "Global scope: " ++ showInterval sgl
-          , "Can skip resolver: " ++ show au]
+          , "Can skip resolver: " ++ if au then "yes" else "no" ]
 
 showInterval :: (Integer, Integer) -> String
 showInterval (n, -1) = show n ++ "..*"
src/Language/Clafer/ClaferArgs.hs view
@@ -77,7 +77,7 @@ 
 clafer :: ClaferArgs
 clafer = ClaferArgs {
-  mode                = [] &= help "Generated output type. Available CLAFERMODEs are: 'alloy' (default, Alloy 4.1); 'alloy42' (Alloy 4.2); 'xml' (intermediate representation of Clafer model); 'clafer' (analyzed and desugared clafer model); 'html' (original model in HTML); 'graph' (graphical representation written in DOT language); 'cvlgraph' (cvl notation representation written in DOT language); 'python' (generates IR in python); 'choco' (Choco constraint programming solver). Multiple modes can be specified at the same time, e.g., '-m alloy -m html'." &= name "m",
+  mode                = [] &= help "Generated output type. Available CLAFERMODEs are: 'alloy' (Alloy 4.1); 'alloy42' (default, Alloy 4.2); 'xml' (intermediate representation of Clafer model); 'clafer' (analyzed and desugared clafer model); 'html' (original model in HTML); 'graph' (graphical representation written in DOT language); 'cvlgraph' (cvl notation representation written in DOT language); 'python' (generates IR in python); 'choco' (Choco constraint programming solver). Multiple modes can be specified at the same time, e.g., '-m alloy -m html'." &= name "m",
   console_output      = def &= help "Output code on console." &= name "o",
   flatten_inheritance = def &= help "Flatten inheritance ('alloy' and 'alloy42' modes only)." &= name "i",
   timeout_analysis    = def &= help "Timeout for analysis.",
@@ -135,11 +135,11 @@              "" -> hGetContents stdin
              f  -> readFile f
   let args'' = argsWithOPTIONS args' model
-  -- Alloy should be the default mode but only if nothing else was specified
-  -- cannot use [ Alloy ] as the default in the definition of `clafer :: ClaferArgs` since 
-  -- Alloy will always be a mode in addition to the other specified modes (it will become mandatory)
+  -- Alloy42 should be the default mode but only if nothing else was specified
+  -- cannot use [ Alloy42 ] as the default in the definition of `clafer :: ClaferArgs` since 
+  -- Alloy42 will always be a mode in addition to the other specified modes (it will become mandatory)
   let args''' = if null $ mode args''
-                then args''{mode = [ Alloy ]}
+                then args''{mode = [ Alloy42 ]}
                 else args''
   return $ (args''', model)
 
src/Language/Clafer/Comments.hs view
@@ -73,13 +73,11 @@ readLine    xs start@(Pos row col) = let comment = takeWhile (/= '\n') xs in 
                                                    ((Span start (Pos row (col + toInteger (length comment)))),
                                                     comment): getComments' (drop (length comment + 1) xs) (row + 1) 1
-readLine    xs (PosPos _ row col)  = readLine xs (Pos row col)
 
 
 readBlock :: String -> Pos -> [(Span, String)]  
 readBlock   xs start@(Pos row col) = let (end@(Pos row' col'), comment, rest) = readBlock' xs row col id in
                                       ((Span start end), comment):getComments' rest row' col'                                    
-readBlock  xs (PosPos _ row col) = readBlock xs (Pos row col)
 readBlock' :: String -> Integer
               -> Integer -> (String -> String)
               -> (Pos, String,String)
src/Language/Clafer/Common.hs view
@@ -327,6 +327,9 @@ integerType :: String
 integerType = "integer"
 
+realType :: String
+realType = "real"
+
 baseClafer :: String
 baseClafer = "clafer"
 
@@ -334,7 +337,7 @@ modSep = "\\"
 
 primitiveTypes :: [String]
-primitiveTypes = [strType, intType, integerType]
+primitiveTypes = [strType, intType, integerType, realType]
 
 isPrimitive :: String -> Bool
 isPrimitive = flip elem primitiveTypes
src/Language/Clafer/Front/Absclafer.hs view
@@ -1,284 +1,371 @@ {-# LANGUAGE DeriveDataTypeable #-}
-
--- | Abstract syntax of the Clafer language.
+{-# LANGUAGE DeriveGeneric #-}
 module Language.Clafer.Front.Absclafer where
 
-import Data.Data
+-- Haskell module generated by the BNF converter
 
-noSpan :: Span
-noSpan = Span noPos noPos
+
+import Data.Data (Data,Typeable)
+import GHC.Generics (Generic)
+data Pos = Pos Integer Integer  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 noPos :: Pos
 noPos = Pos 0 0
 
--- Haskell module generated by the BNF converter
+data Span = Span Pos Pos deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
+noSpan :: Span
+noSpan = Span noPos noPos
 
+class Spannable n where
+  getSpan :: n -> Span
 
-newtype PosInteger = PosInteger ((Int,Int),String) deriving (Eq,Ord,Show)
-newtype PosDouble = PosDouble ((Int,Int),String) deriving (Eq,Ord,Show)
-newtype PosString = PosString ((Int,Int),String) deriving (Eq,Ord,Show)
-newtype PosIdent = PosIdent ((Int,Int),String) deriving (Eq,Ord,Show)
+instance Spannable n => Spannable [n] where
+  getSpan (x:xs) = foldr (\item acc -> getSpan item >- acc ) (getSpan x) xs
+  getSpan [] = noSpan
+
+(>-) :: Span -> Span -> Span
+(>-) (Span (Pos 0 0) (Pos 0 0)) s = s
+(>-) r (Span (Pos 0 0) (Pos 0 0)) = r
+(>-) (Span m _) (Span _ p) = Span m p
+
+len :: [a] -> Integer
+len = toInteger . length
+
+newtype PosInteger = PosInteger ((Int,Int),String) deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
+newtype PosDouble = PosDouble ((Int,Int),String) deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
+newtype PosString = PosString ((Int,Int),String) deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
+newtype PosIdent = PosIdent ((Int,Int),String) deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 data Module =
-   Module [Declaration]
- | PosModule Span [Declaration]
-  deriving (Eq,Ord,Show)
+   Module Span [Declaration]
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Declaration =
-   EnumDecl PosIdent [EnumId]
- | PosEnumDecl Span PosIdent [EnumId]
- | ElementDecl Element
- | PosElementDecl Span Element
-  deriving (Eq,Ord,Show)
+   EnumDecl Span PosIdent [EnumId]
+ | ElementDecl Span Element
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Clafer =
-   Clafer Abstract GCard PosIdent Super Card Init Elements
- | PosClafer Span Abstract GCard PosIdent Super Card Init Elements
-  deriving (Eq,Ord,Show)
+   Clafer Span Abstract GCard PosIdent Super Card Init Elements
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Constraint =
-   Constraint [Exp]
- | PosConstraint Span [Exp]
-  deriving (Eq,Ord,Show)
+   Constraint Span [Exp]
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data SoftConstraint =
-   SoftConstraint [Exp]
- | PosSoftConstraint Span [Exp]
-  deriving (Eq,Ord,Show)
+   SoftConstraint Span [Exp]
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Goal =
-   Goal [Exp]
- | PosGoal Span [Exp]
-  deriving (Eq,Ord,Show)
+   Goal Span [Exp]
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Abstract =
-   AbstractEmpty
- | PosAbstractEmpty Span
- | Abstract
- | PosAbstract Span
-  deriving (Eq,Ord,Show)
+   AbstractEmpty Span
+ | Abstract Span
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Elements =
-   ElementsEmpty
- | PosElementsEmpty Span
- | ElementsList [Element]
- | PosElementsList Span [Element]
-  deriving (Eq,Ord,Show)
+   ElementsEmpty Span
+ | ElementsList Span [Element]
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Element =
-   Subclafer Clafer
- | PosSubclafer Span Clafer
- | ClaferUse Name Card Elements
- | PosClaferUse Span Name Card Elements
- | Subconstraint Constraint
- | PosSubconstraint Span Constraint
- | Subgoal Goal
- | PosSubgoal Span Goal
- | Subsoftconstraint SoftConstraint
- | PosSubsoftconstraint Span SoftConstraint
-  deriving (Eq,Ord,Show)
+   Subclafer Span Clafer
+ | ClaferUse Span Name Card Elements
+ | Subconstraint Span Constraint
+ | Subgoal Span Goal
+ | Subsoftconstraint Span SoftConstraint
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Super =
-   SuperEmpty
- | PosSuperEmpty Span
- | SuperSome SuperHow SetExp
- | PosSuperSome Span SuperHow SetExp
-  deriving (Eq,Ord,Show)
+   SuperEmpty Span
+ | SuperSome Span SuperHow SetExp
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data SuperHow =
-   SuperColon
- | PosSuperColon Span
- | SuperArrow
- | PosSuperArrow Span
- | SuperMArrow
- | PosSuperMArrow Span
-  deriving (Eq,Ord,Show)
+   SuperColon Span
+ | SuperArrow Span
+ | SuperMArrow Span
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Init =
-   InitEmpty
- | PosInitEmpty Span
- | InitSome InitHow Exp
- | PosInitSome Span InitHow Exp
-  deriving (Eq,Ord,Show)
+   InitEmpty Span
+ | InitSome Span InitHow Exp
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data InitHow =
-   InitHow_1
- | PosInitHow_1 Span
- | InitHow_2
- | PosInitHow_2 Span
-  deriving (Eq,Ord,Show)
+   InitHow_1 Span
+ | InitHow_2 Span
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data GCard =
-   GCardEmpty
- | PosGCardEmpty Span
- | GCardXor
- | PosGCardXor Span
- | GCardOr
- | PosGCardOr Span
- | GCardMux
- | PosGCardMux Span
- | GCardOpt
- | PosGCardOpt Span
- | GCardInterval NCard
- | PosGCardInterval Span NCard
-  deriving (Eq,Ord,Show)
+   GCardEmpty Span
+ | GCardXor Span
+ | GCardOr Span
+ | GCardMux Span
+ | GCardOpt Span
+ | GCardInterval Span NCard
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Card =
-   CardEmpty
- | PosCardEmpty Span
- | CardLone
- | PosCardLone Span
- | CardSome
- | PosCardSome Span
- | CardAny
- | PosCardAny Span
- | CardNum PosInteger
- | PosCardNum Span PosInteger
- | CardInterval NCard
- | PosCardInterval Span NCard
-  deriving (Eq,Ord,Show)
+   CardEmpty Span
+ | CardLone Span
+ | CardSome Span
+ | CardAny Span
+ | CardNum Span PosInteger
+ | CardInterval Span NCard
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data NCard =
-   NCard PosInteger ExInteger
- | PosNCard Span PosInteger ExInteger
-  deriving (Eq,Ord,Show)
+   NCard Span PosInteger ExInteger
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data ExInteger =
-   ExIntegerAst
- | PosExIntegerAst Span
- | ExIntegerNum PosInteger
- | PosExIntegerNum Span PosInteger
-  deriving (Eq,Ord,Show)
+   ExIntegerAst Span
+ | ExIntegerNum Span PosInteger
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Name =
-   Path [ModId]
- | PosPath Span [ModId]
-  deriving (Eq,Ord,Show)
+   Path Span [ModId]
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Exp =
-   DeclAllDisj Decl Exp
- | PosDeclAllDisj Span Decl Exp
- | DeclAll Decl Exp
- | PosDeclAll Span Decl Exp
- | DeclQuantDisj Quant Decl Exp
- | PosDeclQuantDisj Span Quant Decl Exp
- | DeclQuant Quant Decl Exp
- | PosDeclQuant Span Quant Decl Exp
- | EGMax Exp
- | PosEGMax Span Exp
- | EGMin Exp
- | PosEGMin Span Exp
- | EIff Exp Exp
- | PosEIff Span Exp Exp
- | EImplies Exp Exp
- | PosEImplies Span Exp Exp
- | EOr Exp Exp
- | PosEOr Span Exp Exp
- | EXor Exp Exp
- | PosEXor Span Exp Exp
- | EAnd Exp Exp
- | PosEAnd Span Exp Exp
- | ENeg Exp
- | PosENeg Span Exp
- | ELt Exp Exp
- | PosELt Span Exp Exp
- | EGt Exp Exp
- | PosEGt Span Exp Exp
- | EEq Exp Exp
- | PosEEq Span Exp Exp
- | ELte Exp Exp
- | PosELte Span Exp Exp
- | EGte Exp Exp
- | PosEGte Span Exp Exp
- | ENeq Exp Exp
- | PosENeq Span Exp Exp
- | EIn Exp Exp
- | PosEIn Span Exp Exp
- | ENin Exp Exp
- | PosENin Span Exp Exp
- | QuantExp Quant Exp
- | PosQuantExp Span Quant Exp
- | EAdd Exp Exp
- | PosEAdd Span Exp Exp
- | ESub Exp Exp
- | PosESub Span Exp Exp
- | EMul Exp Exp
- | PosEMul Span Exp Exp
- | EDiv Exp Exp
- | PosEDiv Span Exp Exp
- | ESumSetExp Exp
- | PosESumSetExp Span Exp
- | ECSetExp Exp
- | PosECSetExp Span Exp
- | EMinExp Exp
- | PosEMinExp Span Exp
- | EImpliesElse Exp Exp Exp
- | PosEImpliesElse Span Exp Exp Exp
- | EInt PosInteger
- | PosEInt Span PosInteger
- | EDouble PosDouble
- | PosEDouble Span PosDouble
- | EStr PosString
- | PosEStr Span PosString
- | ESetExp SetExp
- | PosESetExp Span SetExp
-  deriving (Eq,Ord,Show)
+   DeclAllDisj Span Decl Exp
+ | DeclAll Span Decl Exp
+ | DeclQuantDisj Span Quant Decl Exp
+ | DeclQuant Span Quant Decl Exp
+ | EGMax Span Exp
+ | EGMin Span Exp
+ | EIff Span Exp Exp
+ | EImplies Span Exp Exp
+ | EOr Span Exp Exp
+ | EXor Span Exp Exp
+ | EAnd Span Exp Exp
+ | ENeg Span Exp
+ | ELt Span Exp Exp
+ | EGt Span Exp Exp
+ | EEq Span Exp Exp
+ | ELte Span Exp Exp
+ | EGte Span Exp Exp
+ | ENeq Span Exp Exp
+ | EIn Span Exp Exp
+ | ENin Span Exp Exp
+ | QuantExp Span Quant Exp
+ | EAdd Span Exp Exp
+ | ESub Span Exp Exp
+ | EMul Span Exp Exp
+ | EDiv Span Exp Exp
+ | ESumSetExp Span Exp
+ | ECSetExp Span Exp
+ | EMinExp Span Exp
+ | EImpliesElse Span Exp Exp Exp
+ | EInt Span PosInteger
+ | EDouble Span PosDouble
+ | EStr Span PosString
+ | ESetExp Span SetExp
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data SetExp =
-   Union SetExp SetExp
- | PosUnion Span SetExp SetExp
- | UnionCom SetExp SetExp
- | PosUnionCom Span SetExp SetExp
- | Difference SetExp SetExp
- | PosDifference Span SetExp SetExp
- | Intersection SetExp SetExp
- | PosIntersection Span SetExp SetExp
- | Domain SetExp SetExp
- | PosDomain Span SetExp SetExp
- | Range SetExp SetExp
- | PosRange Span SetExp SetExp
- | Join SetExp SetExp
- | PosJoin Span SetExp SetExp
- | ClaferId Name
- | PosClaferId Span Name
-  deriving (Eq,Ord,Show)
+   Union Span SetExp SetExp
+ | UnionCom Span SetExp SetExp
+ | Difference Span SetExp SetExp
+ | Intersection Span SetExp SetExp
+ | Domain Span SetExp SetExp
+ | Range Span SetExp SetExp
+ | Join Span SetExp SetExp
+ | ClaferId Span Name
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Decl =
-   Decl [LocId] SetExp
- | PosDecl Span [LocId] SetExp
-  deriving (Eq,Ord,Show)
+   Decl Span [LocId] SetExp
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data Quant =
-   QuantNo
- | PosQuantNo Span
- | QuantLone
- | PosQuantLone Span
- | QuantOne
- | PosQuantOne Span
- | QuantSome
- | PosQuantSome Span
-  deriving (Eq,Ord,Show)
+   QuantNo Span
+ | QuantNot Span
+ | QuantLone Span
+ | QuantOne Span
+ | QuantSome Span
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data EnumId =
-   EnumIdIdent PosIdent
- | PosEnumIdIdent Span PosIdent
-  deriving (Eq,Ord,Show)
+   EnumIdIdent Span PosIdent
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data ModId =
-   ModIdIdent PosIdent
- | PosModIdIdent Span PosIdent
-  deriving (Eq,Ord,Show)
+   ModIdIdent Span PosIdent
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
 data LocId =
-   LocIdIdent PosIdent
- | PosLocIdIdent Span PosIdent
-  deriving (Eq,Ord,Show)
+   LocIdIdent Span PosIdent
+  deriving (Eq,Ord,Show,Read,Data,Typeable,Generic)
 
-data Pos =
-   Pos Integer Integer
- | PosPos Span Integer Integer
-  deriving (Eq,Ord,Show,Data,Typeable)
+instance Spannable Module where
+  getSpan ( Module s _ ) = s
 
-data Span =
-   Span Pos Pos
- | PosSpan Span Pos Pos
-  deriving (Eq,Ord,Show,Data,Typeable)
+instance Spannable Declaration where
+  getSpan ( EnumDecl s _ _ ) = s
+  getSpan ( ElementDecl s _ ) = s
+
+instance Spannable Clafer where
+  getSpan ( Clafer s _ _ _ _ _ _ _ ) = s
+
+instance Spannable Constraint where
+  getSpan ( Constraint s _ ) = s
+
+instance Spannable SoftConstraint where
+  getSpan ( SoftConstraint s _ ) = s
+
+instance Spannable Goal where
+  getSpan ( Goal s _ ) = s
+
+instance Spannable Abstract where
+  getSpan ( AbstractEmpty s ) = s
+  getSpan ( Abstract s ) = s
+
+instance Spannable Elements where
+  getSpan ( ElementsEmpty s ) = s
+  getSpan ( ElementsList s _ ) = s
+
+instance Spannable Element where
+  getSpan ( Subclafer s _ ) = s
+  getSpan ( ClaferUse s _ _ _ ) = s
+  getSpan ( Subconstraint s _ ) = s
+  getSpan ( Subgoal s _ ) = s
+  getSpan ( Subsoftconstraint s _ ) = s
+
+instance Spannable Super where
+  getSpan ( SuperEmpty s ) = s
+  getSpan ( SuperSome s _ _ ) = s
+
+instance Spannable SuperHow where
+  getSpan ( SuperColon s ) = s
+  getSpan ( SuperArrow s ) = s
+  getSpan ( SuperMArrow s ) = s
+
+instance Spannable Init where
+  getSpan ( InitEmpty s ) = s
+  getSpan ( InitSome s _ _ ) = s
+
+instance Spannable InitHow where
+  getSpan ( InitHow_1 s ) = s
+  getSpan ( InitHow_2 s ) = s
+
+instance Spannable GCard where
+  getSpan ( GCardEmpty s ) = s
+  getSpan ( GCardXor s ) = s
+  getSpan ( GCardOr s ) = s
+  getSpan ( GCardMux s ) = s
+  getSpan ( GCardOpt s ) = s
+  getSpan ( GCardInterval s _ ) = s
+
+instance Spannable Card where
+  getSpan ( CardEmpty s ) = s
+  getSpan ( CardLone s ) = s
+  getSpan ( CardSome s ) = s
+  getSpan ( CardAny s ) = s
+  getSpan ( CardNum s _ ) = s
+  getSpan ( CardInterval s _ ) = s
+
+instance Spannable NCard where
+  getSpan ( NCard s _ _ ) = s
+
+instance Spannable ExInteger where
+  getSpan ( ExIntegerAst s ) = s
+  getSpan ( ExIntegerNum s _ ) = s
+
+instance Spannable Name where
+  getSpan ( Path s _ ) = s
+
+instance Spannable Exp where
+  getSpan ( DeclAllDisj s _ _ ) = s
+  getSpan ( DeclAll s _ _ ) = s
+  getSpan ( DeclQuantDisj s _ _ _ ) = s
+  getSpan ( DeclQuant s _ _ _ ) = s
+  getSpan ( EGMax s _ ) = s
+  getSpan ( EGMin s _ ) = s
+  getSpan ( EIff s _ _ ) = s
+  getSpan ( EImplies s _ _ ) = s
+  getSpan ( EOr s _ _ ) = s
+  getSpan ( EXor s _ _ ) = s
+  getSpan ( EAnd s _ _ ) = s
+  getSpan ( ENeg s _ ) = s
+  getSpan ( ELt s _ _ ) = s
+  getSpan ( EGt s _ _ ) = s
+  getSpan ( EEq s _ _ ) = s
+  getSpan ( ELte s _ _ ) = s
+  getSpan ( EGte s _ _ ) = s
+  getSpan ( ENeq s _ _ ) = s
+  getSpan ( EIn s _ _ ) = s
+  getSpan ( ENin s _ _ ) = s
+  getSpan ( QuantExp s _ _ ) = s
+  getSpan ( EAdd s _ _ ) = s
+  getSpan ( ESub s _ _ ) = s
+  getSpan ( EMul s _ _ ) = s
+  getSpan ( EDiv s _ _ ) = s
+  getSpan ( ESumSetExp s _ ) = s
+  getSpan ( ECSetExp s _ ) = s
+  getSpan ( EMinExp s _ ) = s
+  getSpan ( EImpliesElse s _ _ _ ) = s
+  getSpan ( EInt s _ ) = s
+  getSpan ( EDouble s _ ) = s
+  getSpan ( EStr s _ ) = s
+  getSpan ( ESetExp s _ ) = s
+
+instance Spannable SetExp where
+  getSpan ( Union s _ _ ) = s
+  getSpan ( UnionCom s _ _ ) = s
+  getSpan ( Difference s _ _ ) = s
+  getSpan ( Intersection s _ _ ) = s
+  getSpan ( Domain s _ _ ) = s
+  getSpan ( Range s _ _ ) = s
+  getSpan ( Join s _ _ ) = s
+  getSpan ( ClaferId s _ ) = s
+
+instance Spannable Decl where
+  getSpan ( Decl s _ _ ) = s
+
+instance Spannable Quant where
+  getSpan ( QuantNo s ) = s
+  getSpan ( QuantNot s ) = s
+  getSpan ( QuantLone s ) = s
+  getSpan ( QuantOne s ) = s
+  getSpan ( QuantSome s ) = s
+
+instance Spannable EnumId where
+  getSpan ( EnumIdIdent s _ ) = s
+
+instance Spannable ModId where
+  getSpan ( ModIdIdent s _ ) = s
+
+instance Spannable LocId where
+  getSpan ( LocIdIdent s _ ) = s
+
+instance Spannable PosInteger where
+  getSpan (PosInteger ((c, l), lex')) =
+    Span (Pos c' l') (Pos c' $ l' + len lex')
+    where
+      c' = toInteger c
+      l' = toInteger l
+
+instance Spannable PosDouble where
+  getSpan (PosDouble ((c, l), lex')) =
+    Span (Pos c' l') (Pos c' $ l' + len lex')
+    where
+      c' = toInteger c
+      l' = toInteger l
+
+instance Spannable PosString where
+  getSpan (PosString ((c, l), lex')) =
+    Span (Pos c' l') (Pos c' $ l' + len lex')
+    where
+      c' = toInteger c
+      l' = toInteger l
+
+instance Spannable PosIdent where
+  getSpan (PosIdent ((c, l), lex')) =
+    Span (Pos c' l') (Pos c' $ l' + len lex')
+    where
+      c' = toInteger c
+      l' = toInteger l
 
src/Language/Clafer/Front/ErrM.hs view
@@ -4,14 +4,14 @@ -- This file comes with NO WARRANTY and may be used FOR ANY PURPOSE.
 module Language.Clafer.Front.ErrM where
 
-import Language.Clafer.Front.Absclafer
-
 -- the Error monad: like Maybe type with error msgs
 
 import Control.Monad (MonadPlus(..), liftM)
+import Control.Applicative (Applicative(..), Alternative(..))
 
+import Language.Clafer.Front.Absclafer
 data Err a = Ok a | Bad Pos String
-  deriving (Show, Eq, Ord)
+  deriving (Read, Show, Eq, Ord)
 
 instance Monad Err where
   return      = Ok
@@ -19,6 +19,12 @@   Ok a  >>= f = f a
   Bad p s >>= _ = Bad p s
 
+instance Applicative Err where
+  pure = Ok
+  (Bad p s) <*> _ = Bad p s
+  (Ok f) <*> o  = liftM f o
+
+
 instance Functor Err where
   fmap = liftM
 
@@ -26,3 +32,7 @@   mzero = Bad noPos "Err.mzero"
   mplus (Bad _ _) y = y
   mplus x       _ = x
+
+instance Alternative Err where
+  empty = mzero
+  (<|>) = mplus
src/Language/Clafer/Front/LayoutResolver.hs view
@@ -91,9 +91,9 @@   st' = dropWhile (newLev <) st
 
 indent :: Token
-indent = PT (Pn 0 0 0) (TS "{" $ tokenLookup "{")
+indent = PT (Pn 0 0 0) (TS "{" $ fromJust $ tokenLookup "{")
 dedent :: Token
-dedent = PT (Pn 0 0 0) (TS "}" $ tokenLookup "}") 
+dedent = PT (Pn 0 0 0) (TS "}" $ fromJust $ tokenLookup "}")
 
 toToken :: ExToken -> [Token]
 toToken (NewLine _) = []
@@ -124,73 +124,17 @@   where
     fPos = Pos (fromIntegral x) (fromIntegral y)
 
-
-tokenLookup :: String -> Int
-tokenLookup s = i
+tokenLookup :: String -> Maybe Int
+tokenLookup s = treeFind resWords
   where
-    i = case s of
-      "!" -> 1
-      "!=" -> 2
-      "#" -> 3
-      "&" -> 4
-      "&&" -> 5
-      "(" -> 6
-      ")" -> 7
-      "*" -> 8
-      "+" -> 9
-      "++" -> 10
-      "," -> 11
-      "-" -> 12
-      "--" -> 13
-      "->" -> 14
-      "->>" -> 15
-      "." -> 16
-      ".." -> 17
-      "/" -> 18
-      ":" -> 19
-      ":=" -> 20
-      ":>" -> 21
-      ";" -> 22
-      "<" -> 23
-      "<:" -> 24
-      "<<" -> 25
-      "<=" -> 26      
-      "<=>" -> 27
-      "=" -> 28
-      "=>" -> 29
-      ">" -> 30
-      ">=" -> 31
-      ">>" -> 32
-      "?" -> 33
-      "[" -> 34
-      "\\" -> 35
-      "]" -> 36
-      "`" -> 37
-      "abstract" -> 38
-      "all" -> 39
-      "disj" -> 40
-      "else" -> 41
-      "enum" -> 42
-      "if" -> 43
-      "in" -> 44
-      "lone" -> 45
-      "max" -> 46
-      "min" -> 47
-      "mux" -> 48
-      "no" -> 49
-      "not" -> 50
-      "one" -> 51
-      "opt" -> 52
-      "or" -> 53
-      "some" -> 54
-      "sum" -> 55       
-      "then" -> 56
-      "xor" -> 57
-      "{" -> 58
-      "|" -> 59
-      "||" -> 60
-      "}" -> 61
-      _ -> 0
+  treeFind N = Nothing
+  treeFind (B a t left right) | s < a  = treeFind left
+                              | s > a  = treeFind right
+                              | s == a = tokenCode t
+  treeFind (B _ _ _ _) = error "LayoutResolver.treeFind should never happen"
+  tokenCode :: Tok -> Maybe Int
+  tokenCode (TS _ c) = Just c
+  tokenCode _ = Nothing
 
 -- | Get the position of a token.
 position :: Token -> Position
@@ -249,9 +193,9 @@   | isLayoutOpen t1  || isBracketOpen t1 =
     addNewLines' (n + 1) (t1:ts) >>= (return . (ExToken t0:))
   | isLayoutClose t1 || isBracketClose t1 =
-    addNewLines' (n - 1) (t1:ts) >>= (return . (ExToken t0:)) 
-  | isNewLine t0 t1  = addNewLines' n (t1:ts) >>= (return . (ExToken t0:) . (NewLine (column t1, n):)) 
-  | otherwise        = addNewLines' n (t1:ts) >>= (return . (ExToken t0:)) 
+    addNewLines' (n - 1) (t1:ts) >>= (return . (ExToken t0:))
+  | isNewLine t0 t1  = addNewLines' n (t1:ts) >>= (return . (ExToken t0:) . (NewLine (column t1, n):))
+  | otherwise        = addNewLines' n (t1:ts) >>= (return . (ExToken t0:))
 addNewLines' _ _ = throwErr (ClaferErr "Function addNewLines' from LayoutResolver was given invalid arguments" :: CErr Span) -- This should never happen!
 
 
@@ -267,8 +211,8 @@   where
   sym = if isLayoutOpen t1 then "{" else "}"
   -- | Get the position immediately to the right of the given token.
-  nextPos :: Token -> Position 
-  nextPos t = Pn (g + s) l (c + s + 1) 
+  nextPos :: Token -> Position
+  nextPos t = Pn (g + s) l (c + s + 1)
     where Pn g l c = position t
           s = tokenLength t
 updToken [] = return []
@@ -281,11 +225,13 @@                      --   positions updated to make room for the new token.
          -> ClaferT m [Token]
 addToken p@(Pn z x y) s ts = do
-  when (i==0) $ throwErr $ ParseErr (ErrPos z fPos fPos) $ "not a reserved word: " ++ show s
-  (>>= (return . (PT p (TS s i):))) $ mapM (incrGlobal p (length s)) ts
+  when (not $ validToken t) $ throwErr $ ParseErr (ErrPos z fPos fPos) $ "not a reserved word: " ++ show s
+  (>>= (return . (PT p (TS s (fromJust t)):))) $ mapM (incrGlobal p (length s)) ts
   where
     fPos = Pos (fromIntegral x) (fromIntegral y)
-    i = tokenLookup s
+    validToken Nothing = False
+    validToken (Just _) = True
+    t = tokenLookup s
 
 resLayout :: String -> String
 resLayout input' = 
− src/Language/Clafer/Front/Lexclafer.hs
@@ -1,393 +0,0 @@-{-# LANGUAGE CPP,MagicHash #-}
-{-# OPTIONS_GHC -w #-}
-{-# LINE 3 "Lexclafer.x" #-}
-
-{-# OPTIONS -fno-warn-incomplete-patterns #-}
-module Language.Clafer.Front.Lexclafer where
-
-
-
-
-#if __GLASGOW_HASKELL__ >= 603
-#include "ghcconfig.h"
-#elif defined(__GLASGOW_HASKELL__)
-#include "config.h"
-#endif
-#if __GLASGOW_HASKELL__ >= 503
-import Data.Array
-import Data.Char (ord)
-import Data.Array.Base (unsafeAt)
-#else
-import Array
-import Char (ord)
-#endif
-#if __GLASGOW_HASKELL__ >= 503
-import GHC.Exts
-#else
-import GlaExts
-#endif
-alex_base :: AlexAddr
-alex_base = AlexA# "\xf8\xff\xff\xff\x4c\x00\x00\x00\x22\x01\x00\x00\xa2\x01\x00\x00\x22\x02\x00\x00\x22\x03\x00\x00\x92\x00\x00\x00\x00\x00\x00\x00\x13\x03\x00\x00\x13\x04\x00\x00\x34\x00\x00\x00\xd3\x03\x00\x00\xa9\x04\x00\x00\x00\x00\x00\x00\x15\x04\x00\x00\x29\x05\x00\x00\x9e\x05\x00\x00\xd9\xff\xff\xff\x4d\x00\x00\x00\x61\x00\x00\x00\x9e\x06\x00\x00\x5e\x06\x00\x00\x00\x00\x00\x00\x54\x07\x00\x00\x00\x00\x00\x00\x2a\x08\x00\x00\x7e\x00\x00\x00\xed\xff\xff\xff\xdc\xff\xff\xff\x4f\x00\x00\x00\xcb\xff\xff\xff\xd6\xff\xff\xff\x00\x00\x00\x00\x99\xff\xff\xff\xd8\xff\xff\xff\x3d\x00\x00\x00\xef\xff\xff\xff\xf9\xff\xff\xff\x79\x00\x00\x00\x2f\x07\x00\x00\x8c\x00\x00\x00\x00\x00\x00\x00\x03\x09\x00\x00"#
-
-alex_table :: AlexAddr
-alex_table = AlexA# "\x00\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x13\x00\x20\x00\x20\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x20\x00\x20\x00\x20\x00\x20\x00\x0c\x00\x1a\x00\x1e\x00\x10\x00\x20\x00\x17\x00\x20\x00\x25\x00\x20\x00\x20\x00\x20\x00\x20\x00\x1c\x00\x20\x00\x1d\x00\x24\x00\x1b\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x1f\x00\x20\x00\x23\x00\x22\x00\x1f\x00\x20\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x20\x00\x20\x00\x20\x00\x10\x00\x00\x00\x20\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x20\x00\x21\x00\x20\x00\x02\x00\x20\x00\x00\x00\x20\x00\x22\x00\x18\x00\x20\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x1a\x00\x00\x00\x22\x00\x00\x00\x00\x00\x10\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x00\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x10\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x03\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x29\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x27\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x16\x00\x15\x00\x03\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0d\x00\x0e\x00\x04\x00\x07\x00\x07\x00\x07\x00\x08\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
-
-alex_check :: AlexAddr
-alex_check = AlexA# "\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x2b\x00\x3d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3d\x00\x3e\x00\x7c\x00\x3e\x00\x2a\x00\x20\x00\x21\x00\x22\x00\x23\x00\x2f\x00\x2e\x00\x26\x00\x26\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x22\x00\xff\xff\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x2a\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x2f\x00\x2d\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x3e\x00\xff\xff\xff\xff\x5c\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\x00\x74\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x22\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xff\xff\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x65\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
-
-alex_deflt :: AlexAddr
-alex_deflt = AlexA# "\xff\xff\x0c\x00\x0c\x00\xff\xff\xff\xff\x0c\x00\x0c\x00\x0d\x00\x0d\x00\x10\x00\xff\xff\x10\x00\x0c\x00\x16\x00\x16\x00\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\x17\x00\x17\x00\x17\x00\x17\x00\xff\xff\x0c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
-
-alex_accept :: Array Int [AlexAcc (Posn -> String -> Token) user]
-alex_accept = listArray (0::Int,42) [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAccSkip)],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_3))],[(AlexAcc (alex_action_4))],[(AlexAcc (alex_action_5))],[(AlexAcc (alex_action_5))],[(AlexAcc (alex_action_6))],[(AlexAcc (alex_action_7))]]
-{-# LINE 39 "Lexclafer.x" #-}
-
-
-tok :: (t1 -> t2 -> t) -> t1 -> t2 -> t
-tok f p s = f p s
-
-share :: String -> String
-share = id
-
-data Tok =
-   TS !String !Int    -- reserved words and symbols
- | TL !String         -- string literals
- | TI !String         -- integer literals
- | TV !String         -- identifiers
- | TD !String         -- double precision float literals
- | TC !String         -- character literals
- | T_PosInteger !String
- | T_PosDouble !String
- | T_PosString !String
- | T_PosIdent !String
-
- deriving (Eq,Show,Ord)
-
-data Token = 
-   PT  Posn Tok
- | Err Posn
-  deriving (Eq,Show,Ord)
-
-tokenPos :: [Token] -> String
-tokenPos (PT (Pn _ l _) _ :_) = "line " ++ show l
-tokenPos (Err (Pn _ l _) :_) = "line " ++ show l
-tokenPos _ = "end of file"
-
-posLineCol :: Posn -> (Int, Int)
-posLineCol (Pn _ l c) = (l,c)
-mkPosToken :: Token -> ((Int, Int), String)
-mkPosToken t@(PT p _) = (posLineCol p, prToken t)
-
-prToken :: Token -> String
-prToken t = case t of
-  PT _ (TS s _) -> s
-  PT _ (TL s)   -> s
-  PT _ (TI s)   -> s
-  PT _ (TV s)   -> s
-  PT _ (TD s)   -> s
-  PT _ (TC s)   -> s
-  PT _ (T_PosInteger s) -> s
-  PT _ (T_PosDouble s) -> s
-  PT _ (T_PosString s) -> s
-  PT _ (T_PosIdent s) -> s
-
-
-data BTree = N | B String Tok BTree BTree deriving (Show)
-
-eitherResIdent :: (String -> Tok) -> String -> Tok
-eitherResIdent tv s = treeFind resWords
-  where
-  treeFind N = tv s
-  treeFind (B a t left right) | s < a  = treeFind left
-                              | s > a  = treeFind right
-                              | s == a = t
-
-resWords :: BTree
-resWords = b ">=" 31 (b "." 16 (b "*" 8 (b "&" 4 (b "!=" 2 (b "!" 1 N N) (b "#" 3 N N)) (b "(" 6 (b "&&" 5 N N) (b ")" 7 N N))) (b "-" 12 (b "++" 10 (b "+" 9 N N) (b "," 11 N N)) (b "->" 14 (b "--" 13 N N) (b "->>" 15 N N)))) (b "<:" 24 (b ":=" 20 (b "/" 18 (b ".." 17 N N) (b ":" 19 N N)) (b ";" 22 (b ":>" 21 N N) (b "<" 23 N N))) (b "=" 28 (b "<=" 26 (b "<<" 25 N N) (b "<=>" 27 N N)) (b ">" 30 (b "=>" 29 N N) N)))) (b "min" 47 (b "all" 39 (b "\\" 35 (b "?" 33 (b ">>" 32 N N) (b "[" 34 N N)) (b "`" 37 (b "]" 36 N N) (b "abstract" 38 N N))) (b "if" 43 (b "else" 41 (b "disj" 40 N N) (b "enum" 42 N N)) (b "lone" 45 (b "in" 44 N N) (b "max" 46 N N)))) (b "sum" 55 (b "one" 51 (b "no" 49 (b "mux" 48 N N) (b "not" 50 N N)) (b "or" 53 (b "opt" 52 N N) (b "some" 54 N N))) (b "|" 59 (b "xor" 57 (b "then" 56 N N) (b "{" 58 N N)) (b "}" 61 (b "||" 60 N N) N))))
-   where b s n = let bs = id s
-                  in B bs (TS bs n)
-
-unescapeInitTail :: String -> String
-unescapeInitTail = id . unesc . tail . id where
-  unesc s = case s of
-    '\\':c:cs | elem c ['\"', '\\', '\''] -> c : unesc cs
-    '\\':'n':cs  -> '\n' : unesc cs
-    '\\':'t':cs  -> '\t' : unesc cs
-    '"':[]    -> []
-    c:cs      -> c : unesc cs
-    _         -> []
-
--------------------------------------------------------------------
--- Alex wrapper code.
--- A modified "posn" wrapper.
--------------------------------------------------------------------
-
-data Posn = Pn !Int !Int !Int
-      deriving (Eq, Show,Ord)
-
-alexStartPos :: Posn
-alexStartPos = Pn 0 1 1
-
-alexMove :: Posn -> Char -> Posn
-alexMove (Pn a l c) '\t' = Pn (a+1)  l     (((c+7) `div` 8)*8+1)
-alexMove (Pn a l _) '\n' = Pn (a+1) (l+1)   1
-alexMove (Pn a l c) _    = Pn (a+1)  l     (c+1)
-
-type AlexInput = (Posn,     -- current position,
-                  Char,     -- previous char
-                  String)   -- current input string
-
-tokens :: String -> [Token]
-tokens str = go (alexStartPos, '\n', str)
-    where
-      go :: AlexInput -> [Token]
-      go inp@(pos, _, str') =
-               case alexScan inp 0 of
-                AlexEOF                -> []
-                AlexError (pos', _, _)  -> [Err pos']
-                AlexSkip  inp' _     -> go inp'
-                AlexToken inp' len act -> act pos (take len str') : (go inp')
-
-alexGetChar :: AlexInput -> Maybe (Char,AlexInput)
-alexGetChar (p, _, s) =
-  case  s of
-    []  -> Nothing
-    (c:s') ->
-             let p' = alexMove p c
-              in p' `seq` Just (c, (p', c, s'))
-
-alexGetByte :: AlexInput -> Maybe (Int,AlexInput)
-alexGetByte i = fmap f (alexGetChar i)
-  where f (c, i') = (fromEnum c, i')
-
-alexInputPrevChar :: AlexInput -> Char
-alexInputPrevChar (_, c, _) = c
-
-alex_action_3 :: Posn -> String -> Token
-alex_action_3 =  tok (\p s -> PT p (eitherResIdent (TV . share) s)) 
-alex_action_4 :: Posn -> String -> Token
-alex_action_4 =  tok (\p s -> PT p (eitherResIdent (T_PosInteger . share) s)) 
-alex_action_5 :: Posn -> String -> Token
-alex_action_5 =  tok (\p s -> PT p (eitherResIdent (T_PosDouble . share) s)) 
-alex_action_6 :: Posn -> String -> Token
-alex_action_6 =  tok (\p s -> PT p (eitherResIdent (T_PosString . share) s)) 
-alex_action_7 :: Posn -> String -> Token
-alex_action_7 =  tok (\p s -> PT p (eitherResIdent (T_PosIdent . share) s)) 
-alex_action_8 :: Posn -> String -> Token
-alex_action_8 =  tok (\p s -> PT p (eitherResIdent (TV . share) s)) 
-alex_action_9 :: Posn -> String -> Token
-alex_action_9 =  tok (\p s -> PT p (TI $ share s))    
-{-# LINE 1 "templates/GenericTemplate.hs" #-}
-{-# LINE 1 "templates/GenericTemplate.hs" #-}
-{-# LINE 1 "<built-in>" #-}
-{-# LINE 1 "<command-line>" #-}
-{-# LINE 1 "templates/GenericTemplate.hs" #-}
--- -----------------------------------------------------------------------------
--- ALEX TEMPLATE
---
--- This code is in the PUBLIC DOMAIN; you may copy it freely and use
--- it for any purpose whatsoever.
-
--- -----------------------------------------------------------------------------
--- INTERNALS and main scanner engine
-
-{-# LINE 37 "templates/GenericTemplate.hs" #-}
-
-{-# LINE 47 "templates/GenericTemplate.hs" #-}
-
-
-data AlexAddr = AlexA# Addr#
-
-#if __GLASGOW_HASKELL__ < 503
-uncheckedShiftL# = shiftL#
-#endif
-
-{-# INLINE alexIndexInt16OffAddr #-}
-alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#
-alexIndexInt16OffAddr (AlexA# arr) off =
-#ifdef WORDS_BIGENDIAN
-  narrow16Int# i
-  where
-        i    = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low)
-        high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))
-        low  = int2Word# (ord# (indexCharOffAddr# arr off'))
-        off' = off *# 2#
-#else
-  indexInt16OffAddr# arr off
-#endif
-
-
-
-
-
-{-# INLINE alexIndexInt32OffAddr #-}
-alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#
-alexIndexInt32OffAddr (AlexA# arr) off = 
-#ifdef WORDS_BIGENDIAN
-  narrow32Int# i
-  where
-   !i    = word2Int# ((b3 `uncheckedShiftL#` 24#) `or#`
-		     (b2 `uncheckedShiftL#` 16#) `or#`
-		     (b1 `uncheckedShiftL#` 8#) `or#` b0)
-   !b3   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 3#)))
-   !b2   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 2#)))
-   !b1   = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#)))
-   !b0   = int2Word# (ord# (indexCharOffAddr# arr off'))
-   !off' = off *# 4#
-#else
-  indexInt32OffAddr# arr off
-#endif
-
-
-
-
-
-#if __GLASGOW_HASKELL__ < 503
-quickIndex arr i = arr ! i
-#else
--- GHC >= 503, unsafeAt is available from Data.Array.Base.
---quickIndex :: Array Int [AlexAcc (Posn -> String -> Token) (Any *)] -> Int -> [AlexAcc (Posn -> String -> Token) (Any *)]
-quickIndex = unsafeAt
-#endif
-
-
-
-
--- -----------------------------------------------------------------------------
--- Main lexing routines
-
-data AlexReturn a
-  = AlexEOF
-  | AlexError  !AlexInput
-  | AlexSkip   !AlexInput !Int
-  | AlexToken  !AlexInput !Int a
-
--- alexScan :: AlexInput -> StartCode -> AlexReturn a
-alexScan :: AlexInput -> Int -> AlexReturn (Posn -> String -> Token)
-alexScan input (I# (sc))
-  = alexScanUser undefined input (I# (sc))
-
---alexScanUser :: Any * -> AlexInput -> Int -> AlexReturn (Posn -> String -> Token)
-alexScanUser user input (I# (sc))
-  = case alex_scan_tkn user input 0# input sc AlexNone of
-	(AlexNone, input') ->
-		case alexGetByte input of
-			Nothing -> 
-
-
-
-				   AlexEOF
-			Just _ ->
-
-
-
-				   AlexError input'
-
-	(AlexLastSkip input'' len, _) ->
-
-
-
-		AlexSkip input'' len
-
-	(AlexLastAcc k input''' len, _) ->
-
-
-
-		AlexToken input''' len k
-
-
--- Push the input through the DFA, remembering the most recent accepting
--- state it encountered.
-
---alex_scan_tkn :: Any * -> AlexInput -> Int# -> AlexInput -> Int# -> AlexLastAcc (Posn -> String -> Token) -> (AlexLastAcc (Posn -> String -> Token), AlexInput)
-alex_scan_tkn user orig_input len input s last_acc =
-  input `seq` -- strict in the input
-  let 
-	new_acc = (check_accs (alex_accept `quickIndex` (I# (s))))
-  in
-  new_acc `seq`
-  case alexGetByte input of
-     Nothing -> (new_acc, input)
-     Just (c, new_input) -> 
-
-
-
-	let
-		(base) = alexIndexInt32OffAddr alex_base s
-		((I# (ord_c))) = fromIntegral c
-		(offset) = (base +# ord_c)
-		(check)  = alexIndexInt16OffAddr alex_check offset
-		
-		(new_s) = if (offset >=# 0#) && (check ==# ord_c)
-			  then alexIndexInt16OffAddr alex_table offset
-			  else alexIndexInt16OffAddr alex_deflt s
-	in
-	case new_s of 
-	    -1# -> (new_acc, input)
-		-- on an error, we want to keep the input *before* the
-		-- character that failed, not after.
-    	    _ -> alex_scan_tkn user orig_input (if c < 0x80 || c >= 0xC0 then (len +# 1#) else len)
-                                                -- note that the length is increased ONLY if this is the 1st byte in a char encoding)
-			new_input new_s new_acc
-
-  where
-	check_accs [] = last_acc
-	check_accs (AlexAcc a : _) = AlexLastAcc a input (I# (len))
-	check_accs (AlexAccSkip : _)  = AlexLastSkip  input (I# (len))
-	check_accs (AlexAccPred a predx : _)
-	   | predx user orig_input (I# (len)) input
-	   = AlexLastAcc a input (I# (len))
-	check_accs (AlexAccSkipPred predx : _)
-	   | predx user orig_input (I# (len)) input
-	   = AlexLastSkip input (I# (len))
-	check_accs (_ : rest) = check_accs rest
-
-data AlexLastAcc a
-  = AlexNone
-  | AlexLastAcc a !AlexInput !Int
-  | AlexLastSkip  !AlexInput !Int
-
-instance Functor AlexLastAcc where
-    fmap _ AlexNone = AlexNone
-    fmap f (AlexLastAcc x y z) = AlexLastAcc (f x) y z
-    fmap _ (AlexLastSkip x y) = AlexLastSkip x y
-
-data AlexAcc a user
-  = AlexAcc a
-  | AlexAccSkip
-  | AlexAccPred a (AlexAccPred user)
-  | AlexAccSkipPred (AlexAccPred user)
-
-type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool
-
--- -----------------------------------------------------------------------------
--- Predicates on a rule
-
-alexAndPred :: (t -> t1 -> t2 -> t3 -> Bool) -> (t -> t1 -> t2 -> t3 -> Bool) -> t -> t1 -> t2 -> t3 -> Bool
-alexAndPred p1 p2 user in1 len in2
-  = p1 user in1 len in2 && p2 user in1 len in2
-
---alexPrevCharIsPred :: Char -> AlexAccPred _ 
-alexPrevCharIs :: Char -> t -> AlexInput -> t1 -> t2 -> Bool
-alexPrevCharIs c _ input _ _ = c == alexInputPrevChar input
-
-alexPrevCharMatches :: (Char -> t3) -> t -> AlexInput -> t1 -> t2 -> t3
-alexPrevCharMatches f _ input _ _ = f (alexInputPrevChar input)
-
---alexPrevCharIsOneOfPred :: Array Char Bool -> AlexAccPred _ 
-alexPrevCharIsOneOf :: Array Char e -> t -> AlexInput -> t1 -> t2 -> e
-alexPrevCharIsOneOf arr _ input _ _ = arr ! alexInputPrevChar input
-
---alexRightContext :: Int -> AlexAccPred _
---alexRightContext :: Int -> Any * -> t -> t1 -> AlexInput -> Bool
-alexRightContext (I# (sc)) user _ _ input = 
-     case alex_scan_tkn user input 0# input sc AlexNone of
-	  (AlexNone, _) -> False
-	  _ -> True
-	-- TODO: there's no need to find the longest
-	-- match when checking the right context, just
-	-- the first match will do.
-
--- used by wrappers
-iUnbox :: Int -> Int#
-iUnbox (I# (i)) = i
+ src/Language/Clafer/Front/Lexclafer.x view
@@ -0,0 +1,182 @@+-- -*- haskell -*-
+-- This Alex file was machine-generated by the BNF converter
+{
+{-# OPTIONS -fno-warn-incomplete-patterns #-}
+{-# OPTIONS_GHC -w #-}
+module Language.Clafer.Front.Lexclafer where
+
+
+
+import qualified Data.Bits
+import Data.Word (Word8)
+}
+
+
+$l = [a-zA-Z\192 - \255] # [\215 \247]    -- isolatin1 letter FIXME
+$c = [A-Z\192-\221] # [\215]    -- capital isolatin1 letter FIXME
+$s = [a-z\222-\255] # [\247]    -- small isolatin1 letter FIXME
+$d = [0-9]                -- digit
+$i = [$l $d _ ']          -- identifier character
+$u = [\0-\255]          -- universal: any character
+
+@rsyms =    -- symbols and non-identifier-like reserved words
+   \= | \[ | \] | \( | \) | \< \< | \> \> | \{ | \} | \` | \: | \- \> | \- \> \> | \: \= | \? | \+ | \* | \. \. | \| | \< \= \> | \= \> | \| \| | \& \& | \! | \< | \> | \< \= | \> \= | \! \= | \- | \/ | \# | \+ \+ | \, | \- \- | \& | \< \: | \: \> | \. | \; | \\
+
+:-
+"//" [.]* ; -- Toss single line comments
+"/*" ([$u # \*] | \* [$u # \/])* ("*")+ "/" ; 
+
+$white+ ;
+@rsyms { tok (\p s -> PT p (eitherResIdent (TV . share) s)) }
+$d + { tok (\p s -> PT p (eitherResIdent (T_PosInteger . share) s)) }
+$d + \. $d + (e \- ? $d +)? { tok (\p s -> PT p (eitherResIdent (T_PosDouble . share) s)) }
+\" ($u # [\" \\]| \\ [\" \\ n t]) * \" { tok (\p s -> PT p (eitherResIdent (T_PosString . share) s)) }
+$l ($l | $d | \_ | \')* { tok (\p s -> PT p (eitherResIdent (T_PosIdent . share) s)) }
+
+$l $i*   { tok (\p s -> PT p (eitherResIdent (TV . share) s)) }
+
+
+
+
+
+{
+
+tok f p s = f p s
+
+share :: String -> String
+share = id
+
+data Tok =
+   TS !String !Int    -- reserved words and symbols
+ | TL !String         -- string literals
+ | TI !String         -- integer literals
+ | TV !String         -- identifiers
+ | TD !String         -- double precision float literals
+ | TC !String         -- character literals
+ | T_PosInteger !String
+ | T_PosDouble !String
+ | T_PosString !String
+ | T_PosIdent !String
+
+ deriving (Eq,Show,Ord)
+
+data Token = 
+   PT  Posn Tok
+ | Err Posn
+  deriving (Eq,Show,Ord)
+
+tokenPos (PT (Pn _ l _) _ :_) = "line " ++ show l
+tokenPos (Err (Pn _ l _) :_) = "line " ++ show l
+tokenPos _ = "end of file"
+
+tokenPosn (PT p _) = p
+tokenPosn (Err p) = p
+tokenLineCol = posLineCol . tokenPosn
+posLineCol (Pn _ l c) = (l,c)
+mkPosToken t@(PT p _) = (posLineCol p, prToken t)
+
+prToken t = case t of
+  PT _ (TS s _) -> s
+  PT _ (TL s)   -> s
+  PT _ (TI s)   -> s
+  PT _ (TV s)   -> s
+  PT _ (TD s)   -> s
+  PT _ (TC s)   -> s
+  PT _ (T_PosInteger s) -> s
+  PT _ (T_PosDouble s) -> s
+  PT _ (T_PosString s) -> s
+  PT _ (T_PosIdent s) -> s
+
+
+data BTree = N | B String Tok BTree BTree deriving (Show)
+
+eitherResIdent :: (String -> Tok) -> String -> Tok
+eitherResIdent tv s = treeFind resWords
+  where
+  treeFind N = tv s
+  treeFind (B a t left right) | s < a  = treeFind left
+                              | s > a  = treeFind right
+                              | s == a = t
+
+resWords = b ">=" 31 (b "." 16 (b "*" 8 (b "&" 4 (b "!=" 2 (b "!" 1 N N) (b "#" 3 N N)) (b "(" 6 (b "&&" 5 N N) (b ")" 7 N N))) (b "-" 12 (b "++" 10 (b "+" 9 N N) (b "," 11 N N)) (b "->" 14 (b "--" 13 N N) (b "->>" 15 N N)))) (b "<:" 24 (b ":=" 20 (b "/" 18 (b ".." 17 N N) (b ":" 19 N N)) (b ";" 22 (b ":>" 21 N N) (b "<" 23 N N))) (b "=" 28 (b "<=" 26 (b "<<" 25 N N) (b "<=>" 27 N N)) (b ">" 30 (b "=>" 29 N N) N)))) (b "min" 47 (b "all" 39 (b "\\" 35 (b "?" 33 (b ">>" 32 N N) (b "[" 34 N N)) (b "`" 37 (b "]" 36 N N) (b "abstract" 38 N N))) (b "if" 43 (b "else" 41 (b "disj" 40 N N) (b "enum" 42 N N)) (b "lone" 45 (b "in" 44 N N) (b "max" 46 N N)))) (b "sum" 55 (b "one" 51 (b "no" 49 (b "mux" 48 N N) (b "not" 50 N N)) (b "or" 53 (b "opt" 52 N N) (b "some" 54 N N))) (b "|" 59 (b "xor" 57 (b "then" 56 N N) (b "{" 58 N N)) (b "}" 61 (b "||" 60 N N) N))))
+   where b s n = let bs = id s
+                  in B bs (TS bs n)
+
+unescapeInitTail :: String -> String
+unescapeInitTail = id . unesc . tail . id where
+  unesc s = case s of
+    '\\':c:cs | elem c ['\"', '\\', '\''] -> c : unesc cs
+    '\\':'n':cs  -> '\n' : unesc cs
+    '\\':'t':cs  -> '\t' : unesc cs
+    '"':[]    -> []
+    c:cs      -> c : unesc cs
+    _         -> []
+
+-------------------------------------------------------------------
+-- Alex wrapper code.
+-- A modified "posn" wrapper.
+-------------------------------------------------------------------
+
+data Posn = Pn !Int !Int !Int
+      deriving (Eq, Show,Ord)
+
+alexStartPos :: Posn
+alexStartPos = Pn 0 1 1
+
+alexMove :: Posn -> Char -> Posn
+alexMove (Pn a l c) '\t' = Pn (a+1)  l     (((c+7) `div` 8)*8+1)
+alexMove (Pn a l c) '\n' = Pn (a+1) (l+1)   1
+alexMove (Pn a l c) _    = Pn (a+1)  l     (c+1)
+
+type Byte = Word8
+
+type AlexInput = (Posn,     -- current position,
+                  Char,     -- previous char
+                  [Byte],   -- pending bytes on the current char
+                  String)   -- current input string
+
+tokens :: String -> [Token]
+tokens str = go (alexStartPos, '\n', [], str)
+    where
+      go :: AlexInput -> [Token]
+      go inp@(pos, _, _, str) =
+               case alexScan inp 0 of
+                AlexEOF                   -> []
+                AlexError (pos, _, _, _)  -> [Err pos]
+                AlexSkip  inp' len        -> go inp'
+                AlexToken inp' len act    -> act pos (take len str) : (go inp')
+
+alexGetByte :: AlexInput -> Maybe (Byte,AlexInput)
+alexGetByte (p, c, (b:bs), s) = Just (b, (p, c, bs, s))
+alexGetByte (p, _, [], s) =
+  case  s of
+    []  -> Nothing
+    (c:s) ->
+             let p'     = alexMove p c
+                 (b:bs) = utf8Encode c
+              in p' `seq` Just (b, (p', c, bs, s))
+
+alexInputPrevChar :: AlexInput -> Char
+alexInputPrevChar (p, c, bs, s) = c
+
+-- | Encode a Haskell String to a list of Word8 values, in UTF8 format.
+utf8Encode :: Char -> [Word8]
+utf8Encode = map fromIntegral . go . ord
+ where
+  go oc
+   | oc <= 0x7f       = [oc]
+
+   | oc <= 0x7ff      = [ 0xc0 + (oc `Data.Bits.shiftR` 6)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+
+   | oc <= 0xffff     = [ 0xe0 + (oc `Data.Bits.shiftR` 12)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+   | otherwise        = [ 0xf0 + (oc `Data.Bits.shiftR` 18)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 12) Data.Bits..&. 0x3f)
+                        , 0x80 + ((oc `Data.Bits.shiftR` 6) Data.Bits..&. 0x3f)
+                        , 0x80 + oc Data.Bits..&. 0x3f
+                        ]
+}
− src/Language/Clafer/Front/Mapper.hs
@@ -1,450 +0,0 @@-{-
- Copyright (C) 2012 Kacper Bak <http://gsd.uwaterloo.ca>
-
- Permission is hereby granted, free of charge, to any person obtaining a copy of
- this software and associated documentation files (the "Software"), to deal in
- the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
--}
-module Language.Clafer.Front.Mapper (mapModule, Mappable(..)) where
-
-import Language.Clafer.Front.Absclafer
-
-
-mapModule :: Module -> Module
-mapModule = mapNode
-
-
-(>-) :: Span -> Span -> Span
-(>-) (Span (Pos 0 0) (Pos 0 0)) s = s
-(>-) r (Span (Pos 0 0) (Pos 0 0)) = r
-(>-) (Span m _) (Span _ p) = Span m p
-(>-) _ _ = error "Function '>-' was not given (Span (Pos 0 0) (Pos 0 0)) as one of it's argumented expected one argument of (Span (Pos 0 0) (Pos 0 0))"
-
-doMap :: Mappable n => (Span -> n -> t) -> n -> t
-doMap f e =
-  f (range e') e'
-  where
-  e' = mapNode e
-
-doMapWithSpan :: Mappable n => (Span -> n -> t) -> Span -> n -> t
-doMapWithSpan f s e = 
-  f (s >- range e') e'
-  where
-  e' = mapNode e
-
-doMap2 :: (Mappable n, Mappable n1) => (Span -> n -> n1 -> t) -> n -> n1 -> t
-doMap2 f d e =
-  f (range d' >- range e') d' e'
-  where
-  d' = mapNode d
-  e' = mapNode e
-
-doMap2WithSpan :: (Mappable n, Mappable n1) => (Span -> n -> n1 -> t) -> Span -> n -> n1 -> t
-doMap2WithSpan f s d e =
-  f (s >- range d' >- range e') d' e'
-  where
-  d' = mapNode d
-  e' = mapNode e
-
-doMap3 :: (Mappable n, Mappable n1, Mappable n2) => (Span -> n -> n1 -> n2 -> t) -> n -> n1 -> n2 -> t
-doMap3 f c d e =
-  f (range c' >- range d' >- range e') c' d' e'
-  where
-  c' = mapNode c
-  d' = mapNode d
-  e' = mapNode e
-
-doMap3WithSpan :: (Mappable n, Mappable n1, Mappable n2) => (Span -> n -> n1 -> n2 -> t) -> Span -> n -> n1 -> n2 -> t
-doMap3WithSpan f s c d e =
-  f (s >- range c' >- range d' >- range e') c' d' e'
-  where
-  c' = mapNode c
-  d' = mapNode d
-  e' = mapNode e
-
-doMap7 :: (Mappable n, Mappable n1, Mappable n2, Mappable n3, Mappable n4, Mappable n5, Mappable n6) => (Span -> n -> n1 -> n2 -> n3 -> n4 -> n5 -> n6 -> t) -> n -> n1 -> n2 -> n3 -> n4 -> n5 -> n6 -> t
-doMap7 f t u v w x y z =
-  f (range t' >- range u' >- range v' >- range w' >- range x' >- range y' >- range z') t' u' v' w' x' y' z'
-  where
-  t' = mapNode t
-  u' = mapNode u
-  v' = mapNode v
-  w' = mapNode w
-  x' = mapNode x
-  y' = mapNode y
-  z' = mapNode z
-
-
-class Mappable n where
-  mapNode :: n -> n
-  range :: n -> Span
-  
-  
-instance Mappable s => Mappable [s] where
-  mapNode = map mapNode
-  range = foldr (>-) noSpan . map range
-
-
-instance Mappable Module where
-  mapNode (Module d) = doMap PosModule d
-  mapNode x = errMsgM "(Module d)" x 
-  range (PosModule s _) = s
-  range x = errMsgR "(PosModule s _)" x
-
-
-instance Mappable Declaration where
-  mapNode (PosEnumDecl s p e) = doMap2WithSpan PosEnumDecl s p e
-  mapNode (ElementDecl e)     = doMap PosElementDecl e
-  mapNode x = errMsgM "(PosEnumDecl s p e) or ElementDecl e)" x 
-  range (PosEnumDecl s _ _)  = s
-  range (PosElementDecl s _) = s
-  range x = errMsgR "(PosEnumDecl s p e) or (PosElementDecl s e)" x
-
-
-instance Mappable Elements where
-  mapNode ElementsEmpty         = PosElementsEmpty noSpan
-  -- The span is inaccurate for some apparent reason. Not sure why yet.
-  mapNode (PosElementsList _ e) = doMap PosElementsList e --doMapWithSpan PosElementsList s e
-  mapNode x = errMsgM "ElementsEmpty or (PosElementsList s e)" x
-  range (PosElementsEmpty s)  = s
-  range (PosElementsList s _) = s
-  range x = errMsgR "(PosElementsEmpty s) or (PosElementsList s _)" x
-
-
-instance Mappable Element where
-  mapNode (Subclafer c)          = doMap PosSubclafer c
-  mapNode (PosClaferUse s n c e) = doMap3WithSpan PosClaferUse s n c e
-  mapNode (Subconstraint c)      = doMap PosSubconstraint c
-  mapNode (Subgoal g)            = doMap PosSubgoal g
-  mapNode (Subsoftconstraint c)  = doMap PosSubsoftconstraint c
-  mapNode x = errMsgM "(Subclafer c), (PosClaferUse s n c e), (Subconstraint c), (Subgoal g), or (Subsoftconstraint c)" x
-  range (PosSubclafer s _)         = s
-  range (PosClaferUse s _ _ _)     = s
-  range (PosSubconstraint s _)     = s
-  range (PosSubgoal s _)           = s
-  range (PosSubsoftconstraint s _) = s
-  range x = errMsgR "(PosSubclafer s _), (PosClaferUse s _ _ _), (PosSubconstraint s _), (PosSubgoal s _), (PosSubsoftconstraint s _)" x
-  
-  
-instance Mappable Clafer where
-  mapNode (Clafer a b c d e f g) = doMap7 PosClafer a b c d e f g
-  mapNode x = errMsgM "(Clafer a b c d e f g)" x
-  range (PosClafer s _ _ _ _ _ _ _) = s
-  range x = errMsgR "(PosClafer s _ _ _ _ _ _ _)" x
-  
-  
-instance Mappable Constraint where
---  mapNode (PosConstraint s e) = doMapWithSpan PosConstraint s e
---  The span in the PosConstraint contains the span of the "[" after lexing.
---  However, we don't have the span of the "]". It doesn't make sense to include
---  one but not the other. Hence, ignore the "[" position and start with the first
---  expression in the constraint instead.
-  mapNode (PosConstraint _ e) = doMap PosConstraint e
-  mapNode x = errMsgM "(PosConstraint s e)" x
-  range (PosConstraint s _) = s
-  range x = errMsgR "(PosConstraint s _)" x
-
-
-instance Mappable SoftConstraint where
-  mapNode (PosSoftConstraint s e) = doMapWithSpan PosSoftConstraint s e
-  mapNode x = errMsgM "(PosSoftConstraint s e)" x
-  range (PosSoftConstraint s _) = s
-  range x = errMsgR "(PosSoftConstraint s _)" x
-  
-  
-instance Mappable Goal where
-  mapNode (PosGoal s e) = doMapWithSpan PosGoal s e
-  mapNode x = errMsgM "(PosGoal s e)" x
-  range (PosGoal s _) = s
-  range x = errMsgR "(PosGoal s _)" x
-  
-  
-instance Mappable Abstract where
-  mapNode AbstractEmpty   = PosAbstractEmpty noSpan
-  mapNode x@PosAbstract{} = x
-  mapNode x = errMsgM "AbstractEmpty or x@PosAbstract{}"x 
-  range (PosAbstractEmpty s) = s
-  range (PosAbstract s)      = s
-  range x = errMsgR "(PosAbstractEmpty s) or (PosAbstract s)" x
-
-
-instance Mappable Super where
-  mapNode SuperEmpty          = PosSuperEmpty noSpan
-  mapNode (SuperSome how exp'') = doMap2 PosSuperSome how exp''
-  mapNode x = errMsgM "SuperEmpty or (SuperSome how exp')" x
-  range (PosSuperEmpty s)    = s
-  range (PosSuperSome s _ _) = s
-  range x = errMsgR "(PosSuperEmpty s) or (PosSuperSome s _ _)" x
-
-
-instance Mappable SuperHow where
-  mapNode = id
-  range (PosSuperColon s)   = s
-  range (PosSuperArrow s)   = s
-  range (PosSuperMArrow  s) = s
-  range x = errMsgR "(PosSuperColon s), (PosSuperArrow s), or (PosSuperMArrow  s) " x
-
-
-instance Mappable Init where
-  mapNode InitEmpty          = PosInitEmpty noSpan
-  mapNode (InitSome how exp'') = doMap2 PosInitSome how exp''
-  mapNode x = errMsgM "InitEmpty or (InitSome how exp')" x
-  range (PosInitEmpty s)    = s
-  range (PosInitSome s _ _) = s
-  range x = errMsgR "(PosInitEmpty s) or (PosInitSome s _ _)" x
-  
-  
-instance Mappable InitHow where
-  mapNode = id
-  range (PosInitHow_1 s) = s
-  range (PosInitHow_2 s) = s
-  range x = errMsgR "(PosInitHow_1 s) or (PosInitHow_2 s)" x
-
-
-instance Mappable Decl where
-  mapNode (Decl l e) = doMap2 PosDecl l e
-  mapNode x = errMsgM "(Decl l e)" x
-  range (PosDecl s _ _) = s
-  range x = errMsgR "(PosDecl s _ _)" x
-
-
-instance Mappable Exp where
-  mapNode (PosDeclAllDisj s decl exp')    = doMap2WithSpan PosDeclAllDisj s decl exp'
-  mapNode (PosDeclAll s decl exp')        = doMap2WithSpan PosDeclAll s decl exp'
-  mapNode (DeclQuantDisj quant decl exp') = doMap3 PosDeclQuantDisj quant decl exp'
-  mapNode (DeclQuant quant decl exp')     = doMap3 PosDeclQuant quant decl exp'
-  mapNode (PosEGMax s exp')               = doMapWithSpan PosEGMax s exp'
-  mapNode (PosEGMin s exp')               = doMapWithSpan PosEGMin s exp'
-  mapNode (EIff exp0 exp1)               = doMap2 PosEIff exp0 exp1
-  mapNode (EImplies exp0 exp1)           = doMap2 PosEImplies exp0 exp1
-  mapNode (EOr exp0 exp1)                = doMap2 PosEOr exp0 exp1
-  mapNode (EXor exp0 exp1)               = doMap2 PosEXor exp0 exp1
-  mapNode (EAnd exp0 exp1)               = doMap2 PosEAnd exp0 exp1
-  mapNode (PosENeg s exp')                = doMapWithSpan PosENeg s exp'
-  mapNode (ELt exp0 exp1)                = doMap2 PosELt exp0 exp1
-  mapNode (EGt exp0 exp1)                = doMap2 PosEGt exp0 exp1
-  mapNode (EEq exp0 exp1)                = doMap2 PosEEq exp0 exp1
-  mapNode (ELte exp0 exp1)               = doMap2 PosELte exp0 exp1
-  mapNode (EGte exp0 exp1)               = doMap2 PosEGte exp0 exp1
-  mapNode (ENeq exp0 exp1)               = doMap2 PosENeq exp0 exp1
-  mapNode (EIn exp0 exp1)                = doMap2 PosEIn exp0 exp1
-  mapNode (ENin exp0 exp1)               = doMap2 PosENin exp0 exp1
-  mapNode (QuantExp quant exp')           = doMap2 PosQuantExp quant exp'
-  mapNode (EAdd exp0 exp1)               = doMap2 PosEAdd exp0 exp1
-  mapNode (ESub exp0 exp1)               = doMap2 PosESub exp0 exp1
-  mapNode (EMul exp0 exp1)               = doMap2 PosEMul exp0 exp1
-  mapNode (EDiv exp0 exp1)               = doMap2 PosEDiv exp0 exp1
-  mapNode (PosECSetExp s exp')            = doMapWithSpan PosECSetExp s exp'
-  mapNode (PosEMinExp s exp')             = doMapWithSpan PosEMinExp s exp'  
-  mapNode (PosESumSetExp s exp')             = doMapWithSpan PosESumSetExp s exp'
-  mapNode (PosEImpliesElse s exp0 exp1 exp2) = doMap3WithSpan PosEImpliesElse s exp0 exp1 exp2
-  mapNode (EInt posinteger)              = doMap PosEInt posinteger
-  mapNode (EDouble posdouble)            = doMap PosEDouble posdouble
-  mapNode (EStr posstring)               = doMap PosEStr posstring
-  mapNode (ESetExp setexp)               = doMap PosESetExp setexp
-  mapNode x = errMsgM "Exp" x
-  range (PosDeclAllDisj s _ _)    = s
-  range (PosDeclAll s _ _)        = s
-  range (PosDeclQuantDisj s _ _ _) = s
-  range (PosDeclQuant s _ _ _)    = s
-  range (PosEGMax s _)            = s
-  range (PosEGMin s _)            = s
-  range (PosEIff s _ _)           = s
-  range (PosEImplies s _ _)       = s
-  range (PosEOr s _ _)            = s
-  range (PosEXor s _ _)           = s
-  range (PosEAnd s _ _)           = s
-  range (PosENeg s _)             = s
-  range (PosELt s _ _)            = s
-  range (PosEGt s _ _)            = s
-  range (PosEEq s _ _)            = s
-  range (PosELte s _ _)           = s
-  range (PosEGte s _ _)           = s
-  range (PosENeq s _ _)           = s
-  range (PosEIn s _ _)            = s
-  range (PosENin s _ _)           = s
-  range (PosQuantExp s _ _)       = s
-  range (PosEAdd s _ _)           = s
-  range (PosESub s _ _)           = s
-  range (PosEMul s _ _)           = s
-  range (PosEDiv s _ _)           = s
-  range (PosECSetExp s _)         = s
-  range (PosESumSetExp s _)         = s
-  range (PosEMinExp s _)          = s
-  range (PosEImpliesElse s _ _ _) = s
-  range (PosEInt s _)             = s
-  range (PosEDouble s _)          = s
-  range (PosEStr s _)             = s
-  range (PosESetExp s _)          = s
-  range x = error $ "No position for Exp " ++ show x
-  
-  
-instance Mappable SetExp where
-  mapNode (Union e1 e2)        = doMap2 PosUnion e1 e2
-  mapNode (UnionCom e1 e2)     = doMap2 PosUnionCom e1 e2
-  mapNode (Difference e1 e2)   = doMap2 PosDifference e1 e2
-  mapNode (Intersection e1 e2) = doMap2 PosIntersection e1 e2
-  mapNode (Domain e1 e2)       = doMap2 PosDomain e1 e2
-  mapNode (Range e1 e2)        = doMap2 PosRange e1 e2
-  mapNode (Join e1 e2)         = doMap2 PosJoin e1 e2
-  mapNode (ClaferId n)         = doMap PosClaferId n
-  mapNode x = errMsgM "SetExp" x
-  range (PosUnion s _ _)        = s
-  range (PosUnionCom s _ _)     = s
-  range (PosDifference s _ _)   = s
-  range (PosIntersection s _ _) = s
-  range (PosDomain s _ _)       = s
-  range (PosRange s _ _)        = s
-  range (PosJoin s _ _)         = s
-  range (PosClaferId s _)       = s
-  range x = errMsgR "SetExp" x
-  
-
-instance Mappable NCard where
-  mapNode (NCard l h) = doMap2 PosNCard l h
-  mapNode x = errMsgM "(NCard l h)" x
-  range (PosNCard s _ _) = s
-  range x = errMsgR "(PosNCard s _ _)" x
-  
-  
-instance Mappable Card where
-  mapNode CardEmpty        = PosCardEmpty noSpan
-  mapNode x@PosCardLone{}  = x
-  mapNode x@PosCardSome{}  = x
-  mapNode x@PosCardAny{}   = x
-  mapNode (CardNum i)      = doMap PosCardNum i 
-  mapNode (CardInterval c) = doMap PosCardInterval c
-  mapNode x = errMsgM "Card" x
-  range (PosCardEmpty s) = s
-  range (PosCardLone s)  = s
-  range (PosCardSome s)  = s
-  range (PosCardAny s)   = s
-  range (PosCardNum s _) = s
-  range (PosCardInterval s _) = s
-  range x = errMsgR "Card" x
-  
-  
-instance Mappable GCard where
-  mapNode GCardEmpty        = PosGCardEmpty noSpan
-  mapNode x@PosGCardXor{}   = x
-  mapNode x@PosGCardOr{}    = x
-  mapNode x@PosGCardMux{}   = x
-  mapNode x@PosGCardOpt{}   = x
-  mapNode (GCardInterval n) = doMap PosGCardInterval n
-  mapNode x = errMsgM "GCard" x
-  range (PosGCardEmpty s)      = s
-  range (PosGCardXor s)        = s
-  range (PosGCardOr s)         = s
-  range (PosGCardMux s)        = s
-  range (PosGCardOpt s)        = s
-  range (PosGCardInterval s _) = s
-  range x = errMsgR "GCard" x
-
-
-instance Mappable Name where
-  mapNode (Path m) = doMap PosPath m
-  mapNode x = errMsgM "(Path m)" x
-  range (PosPath s _) = s
-  range x = errMsgR "(PosPath s _)" x
-  
-
-instance Mappable LocId where
-  mapNode (LocIdIdent i) = doMap PosLocIdIdent i
-  mapNode x = errMsgM "(LocIdIdent i)" x
-  range (PosLocIdIdent s _) = s
-  range x = errMsgR "(PosLocIdIdent s _)" x
-  
-
-instance Mappable ModId where
-  mapNode (ModIdIdent i) = doMap PosModIdIdent i
-  mapNode x = errMsgM "(ModIdIdent i)" x
-  range (PosModIdIdent s _) = s
-  range x = errMsgR "(PosModIdIdent s _)" x
-
-
-instance Mappable EnumId where
-  mapNode (EnumIdIdent i) = doMap PosEnumIdIdent i
-  mapNode x = errMsgM "(EnumIdIdent i)" x
-  range (PosEnumIdIdent s _) = s
-  range x = errMsgR "(PosEnumIdIdent s _)" x
-  
-  
-instance Mappable Quant where
-  mapNode = id
-  range (PosQuantNo s)   = s
-  range (PosQuantLone s) = s
-  range (PosQuantOne s)  = s
-  range (PosQuantSome s) = s
-  range x = errMsgR "(PosQuantNo s), (PosQuantLone s), (PosQuantOne s), or (PosQuantSome s)" x
-
-
-
-instance Mappable ExInteger where
-  mapNode x@PosExIntegerAst{} = x
-  mapNode (ExIntegerNum i)    = doMap PosExIntegerNum i
-  mapNode x = errMsgM "x@PosExIntegerAst{} or (ExIntegerNum i)" x
-  range (PosExIntegerAst s)   = s
-  range (PosExIntegerNum s _) = s  
-  range x = errMsgR "(PosExIntegerAst s) or (PosExIntegerNum s _)" x
-
-
-instance Mappable PosIdent where
-  mapNode = id
-  range (PosIdent ((c, l), lex')) =
-    Span (Pos c' l') (Pos c' $ l' + len lex')
-    where
-    c' = toInteger c
-    l' = toInteger l
-
-
-instance Mappable PosString where
-  mapNode = id
-  range (PosString ((c, l), lex')) =
-    Span (Pos c' l') (Pos c' $ l' + len lex')
-    where
-    c' = toInteger c
-    l' = toInteger l
-
-  
-instance Mappable PosDouble where
-  mapNode = id  
-  range (PosDouble ((c, l), lex')) =
-    Span (Pos c' l') (Pos c' $ l' + len lex')
-    where
-    c' = toInteger c
-    l' = toInteger l
-
-  
-  
-instance Mappable PosInteger where
-  mapNode = id  
-  range (PosInteger ((c, l), lex')) =
-    Span (Pos c' l') (Pos c' $ l' + len lex')
-    where
-    c' = toInteger c
-    l' = toInteger l
-
-
-len :: [a] -> Integer
-len = toInteger . length
-
-errMsg :: Show a => String -> String -> a -> t
-errMsg function expected actual = error $ "Error: Function '" ++ function ++ "' expected argument of type(s) " ++ expected ++ " got " ++ show actual
-errMsgM :: Show a => String -> a -> t
-errMsgM e a = errMsg "mapNode" e a
-errMsgR :: Show a => String -> a -> t
-errMsgR e a = errMsg "range" e a
− src/Language/Clafer/Front/Parclafer.hs
@@ -1,1978 +0,0 @@-{-# OPTIONS_GHC -w #-}
-{-# OPTIONS -fglasgow-exts -cpp #-}
-{-# OPTIONS -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
-module Language.Clafer.Front.Parclafer where
-import Language.Clafer.Front.Absclafer
-import Language.Clafer.Front.Lexclafer
-import Language.Clafer.Front.ErrM
-import qualified Data.Array as Happy_Data_Array
-import qualified GHC.Exts as Happy_GHC_Exts
-
--- parser produced by Happy Version 1.18.9
-
-newtype HappyAbsSyn  = HappyAbsSyn HappyAny
-#if __GLASGOW_HASKELL__ >= 607
-type HappyAny = Happy_GHC_Exts.Any
-#else
-type HappyAny = forall a . a
-#endif
-happyIn4 :: (Integer) -> (HappyAbsSyn )
-happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn4 #-}
-happyOut4 :: (HappyAbsSyn ) -> (Integer)
-happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut4 #-}
-happyIn5 :: (PosInteger) -> (HappyAbsSyn )
-happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn5 #-}
-happyOut5 :: (HappyAbsSyn ) -> (PosInteger)
-happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut5 #-}
-happyIn6 :: (PosDouble) -> (HappyAbsSyn )
-happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn6 #-}
-happyOut6 :: (HappyAbsSyn ) -> (PosDouble)
-happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut6 #-}
-happyIn7 :: (PosString) -> (HappyAbsSyn )
-happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn7 #-}
-happyOut7 :: (HappyAbsSyn ) -> (PosString)
-happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut7 #-}
-happyIn8 :: (PosIdent) -> (HappyAbsSyn )
-happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn8 #-}
-happyOut8 :: (HappyAbsSyn ) -> (PosIdent)
-happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut8 #-}
-happyIn9 :: (Module) -> (HappyAbsSyn )
-happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn9 #-}
-happyOut9 :: (HappyAbsSyn ) -> (Module)
-happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut9 #-}
-happyIn10 :: (Declaration) -> (HappyAbsSyn )
-happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn10 #-}
-happyOut10 :: (HappyAbsSyn ) -> (Declaration)
-happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut10 #-}
-happyIn11 :: (Clafer) -> (HappyAbsSyn )
-happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn11 #-}
-happyOut11 :: (HappyAbsSyn ) -> (Clafer)
-happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut11 #-}
-happyIn12 :: (Constraint) -> (HappyAbsSyn )
-happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn12 #-}
-happyOut12 :: (HappyAbsSyn ) -> (Constraint)
-happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut12 #-}
-happyIn13 :: (SoftConstraint) -> (HappyAbsSyn )
-happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn13 #-}
-happyOut13 :: (HappyAbsSyn ) -> (SoftConstraint)
-happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut13 #-}
-happyIn14 :: (Goal) -> (HappyAbsSyn )
-happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn14 #-}
-happyOut14 :: (HappyAbsSyn ) -> (Goal)
-happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut14 #-}
-happyIn15 :: (Abstract) -> (HappyAbsSyn )
-happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn15 #-}
-happyOut15 :: (HappyAbsSyn ) -> (Abstract)
-happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut15 #-}
-happyIn16 :: (Elements) -> (HappyAbsSyn )
-happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn16 #-}
-happyOut16 :: (HappyAbsSyn ) -> (Elements)
-happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut16 #-}
-happyIn17 :: (Element) -> (HappyAbsSyn )
-happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn17 #-}
-happyOut17 :: (HappyAbsSyn ) -> (Element)
-happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut17 #-}
-happyIn18 :: (Super) -> (HappyAbsSyn )
-happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn18 #-}
-happyOut18 :: (HappyAbsSyn ) -> (Super)
-happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut18 #-}
-happyIn19 :: (SuperHow) -> (HappyAbsSyn )
-happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn19 #-}
-happyOut19 :: (HappyAbsSyn ) -> (SuperHow)
-happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut19 #-}
-happyIn20 :: (Init) -> (HappyAbsSyn )
-happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn20 #-}
-happyOut20 :: (HappyAbsSyn ) -> (Init)
-happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut20 #-}
-happyIn21 :: (InitHow) -> (HappyAbsSyn )
-happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn21 #-}
-happyOut21 :: (HappyAbsSyn ) -> (InitHow)
-happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut21 #-}
-happyIn22 :: (GCard) -> (HappyAbsSyn )
-happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn22 #-}
-happyOut22 :: (HappyAbsSyn ) -> (GCard)
-happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut22 #-}
-happyIn23 :: (Card) -> (HappyAbsSyn )
-happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn23 #-}
-happyOut23 :: (HappyAbsSyn ) -> (Card)
-happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut23 #-}
-happyIn24 :: (NCard) -> (HappyAbsSyn )
-happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn24 #-}
-happyOut24 :: (HappyAbsSyn ) -> (NCard)
-happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut24 #-}
-happyIn25 :: (ExInteger) -> (HappyAbsSyn )
-happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn25 #-}
-happyOut25 :: (HappyAbsSyn ) -> (ExInteger)
-happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut25 #-}
-happyIn26 :: (Name) -> (HappyAbsSyn )
-happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn26 #-}
-happyOut26 :: (HappyAbsSyn ) -> (Name)
-happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut26 #-}
-happyIn27 :: (Exp) -> (HappyAbsSyn )
-happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn27 #-}
-happyOut27 :: (HappyAbsSyn ) -> (Exp)
-happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut27 #-}
-happyIn28 :: (Exp) -> (HappyAbsSyn )
-happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn28 #-}
-happyOut28 :: (HappyAbsSyn ) -> (Exp)
-happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut28 #-}
-happyIn29 :: (Exp) -> (HappyAbsSyn )
-happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn29 #-}
-happyOut29 :: (HappyAbsSyn ) -> (Exp)
-happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut29 #-}
-happyIn30 :: (Exp) -> (HappyAbsSyn )
-happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn30 #-}
-happyOut30 :: (HappyAbsSyn ) -> (Exp)
-happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut30 #-}
-happyIn31 :: (Exp) -> (HappyAbsSyn )
-happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn31 #-}
-happyOut31 :: (HappyAbsSyn ) -> (Exp)
-happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut31 #-}
-happyIn32 :: (Exp) -> (HappyAbsSyn )
-happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn32 #-}
-happyOut32 :: (HappyAbsSyn ) -> (Exp)
-happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut32 #-}
-happyIn33 :: (Exp) -> (HappyAbsSyn )
-happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn33 #-}
-happyOut33 :: (HappyAbsSyn ) -> (Exp)
-happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut33 #-}
-happyIn34 :: (Exp) -> (HappyAbsSyn )
-happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn34 #-}
-happyOut34 :: (HappyAbsSyn ) -> (Exp)
-happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut34 #-}
-happyIn35 :: (Exp) -> (HappyAbsSyn )
-happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn35 #-}
-happyOut35 :: (HappyAbsSyn ) -> (Exp)
-happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut35 #-}
-happyIn36 :: (Exp) -> (HappyAbsSyn )
-happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn36 #-}
-happyOut36 :: (HappyAbsSyn ) -> (Exp)
-happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut36 #-}
-happyIn37 :: (Exp) -> (HappyAbsSyn )
-happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn37 #-}
-happyOut37 :: (HappyAbsSyn ) -> (Exp)
-happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut37 #-}
-happyIn38 :: (Exp) -> (HappyAbsSyn )
-happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn38 #-}
-happyOut38 :: (HappyAbsSyn ) -> (Exp)
-happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut38 #-}
-happyIn39 :: (Exp) -> (HappyAbsSyn )
-happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn39 #-}
-happyOut39 :: (HappyAbsSyn ) -> (Exp)
-happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut39 #-}
-happyIn40 :: (Exp) -> (HappyAbsSyn )
-happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn40 #-}
-happyOut40 :: (HappyAbsSyn ) -> (Exp)
-happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut40 #-}
-happyIn41 :: (SetExp) -> (HappyAbsSyn )
-happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn41 #-}
-happyOut41 :: (HappyAbsSyn ) -> (SetExp)
-happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut41 #-}
-happyIn42 :: (SetExp) -> (HappyAbsSyn )
-happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn42 #-}
-happyOut42 :: (HappyAbsSyn ) -> (SetExp)
-happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut42 #-}
-happyIn43 :: (SetExp) -> (HappyAbsSyn )
-happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn43 #-}
-happyOut43 :: (HappyAbsSyn ) -> (SetExp)
-happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut43 #-}
-happyIn44 :: (SetExp) -> (HappyAbsSyn )
-happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn44 #-}
-happyOut44 :: (HappyAbsSyn ) -> (SetExp)
-happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut44 #-}
-happyIn45 :: (SetExp) -> (HappyAbsSyn )
-happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn45 #-}
-happyOut45 :: (HappyAbsSyn ) -> (SetExp)
-happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut45 #-}
-happyIn46 :: (SetExp) -> (HappyAbsSyn )
-happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn46 #-}
-happyOut46 :: (HappyAbsSyn ) -> (SetExp)
-happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut46 #-}
-happyIn47 :: (SetExp) -> (HappyAbsSyn )
-happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn47 #-}
-happyOut47 :: (HappyAbsSyn ) -> (SetExp)
-happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut47 #-}
-happyIn48 :: (Decl) -> (HappyAbsSyn )
-happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn48 #-}
-happyOut48 :: (HappyAbsSyn ) -> (Decl)
-happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut48 #-}
-happyIn49 :: (Quant) -> (HappyAbsSyn )
-happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn49 #-}
-happyOut49 :: (HappyAbsSyn ) -> (Quant)
-happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut49 #-}
-happyIn50 :: (EnumId) -> (HappyAbsSyn )
-happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn50 #-}
-happyOut50 :: (HappyAbsSyn ) -> (EnumId)
-happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut50 #-}
-happyIn51 :: (ModId) -> (HappyAbsSyn )
-happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn51 #-}
-happyOut51 :: (HappyAbsSyn ) -> (ModId)
-happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut51 #-}
-happyIn52 :: (LocId) -> (HappyAbsSyn )
-happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn52 #-}
-happyOut52 :: (HappyAbsSyn ) -> (LocId)
-happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut52 #-}
-happyIn53 :: (Pos) -> (HappyAbsSyn )
-happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn53 #-}
-happyOut53 :: (HappyAbsSyn ) -> (Pos)
-happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut53 #-}
-happyIn54 :: (Span) -> (HappyAbsSyn )
-happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn54 #-}
-happyOut54 :: (HappyAbsSyn ) -> (Span)
-happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut54 #-}
-happyIn55 :: ([Declaration]) -> (HappyAbsSyn )
-happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn55 #-}
-happyOut55 :: (HappyAbsSyn ) -> ([Declaration])
-happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut55 #-}
-happyIn56 :: ([EnumId]) -> (HappyAbsSyn )
-happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn56 #-}
-happyOut56 :: (HappyAbsSyn ) -> ([EnumId])
-happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut56 #-}
-happyIn57 :: ([Element]) -> (HappyAbsSyn )
-happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn57 #-}
-happyOut57 :: (HappyAbsSyn ) -> ([Element])
-happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut57 #-}
-happyIn58 :: ([Exp]) -> (HappyAbsSyn )
-happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn58 #-}
-happyOut58 :: (HappyAbsSyn ) -> ([Exp])
-happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut58 #-}
-happyIn59 :: ([LocId]) -> (HappyAbsSyn )
-happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn59 #-}
-happyOut59 :: (HappyAbsSyn ) -> ([LocId])
-happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut59 #-}
-happyIn60 :: ([ModId]) -> (HappyAbsSyn )
-happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyIn60 #-}
-happyOut60 :: (HappyAbsSyn ) -> ([ModId])
-happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOut60 #-}
-happyInTok :: (Token) -> (HappyAbsSyn )
-happyInTok x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyInTok #-}
-happyOutTok :: (HappyAbsSyn ) -> (Token)
-happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x
-{-# INLINE happyOutTok #-}
-
-
-happyActOffsets :: HappyAddr
-happyActOffsets = HappyA# "\x00\x00\x1e\x01\x00\x00\x16\x01\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x01\x00\x00\x17\x01\x3b\x01\x00\x00\x00\x00\x06\x00\x35\x01\x00\x00\x4c\x00\x1d\x00\x01\x00\x27\x01\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x01\x1a\x01\xfa\x00\xf5\x00\x26\x01\x00\x00\xdd\x05\x00\x00\x69\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x92\x00\x1d\x01\x24\x01\x0a\x01\x0b\x01\xf9\x00\x00\x00\xa6\x00\x9f\x00\xb2\x00\x68\x00\x00\x00\xb2\x00\xe4\xff\xb2\x00\x00\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\xf6\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\xc5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\xb2\x00\xdd\x00\xc4\x00\x00\x00\xb5\x00\xd5\x00\xd6\x00\xa8\x00\x00\x00\xdc\x00\xd0\x00\x00\x00\xdd\x05\x28\x00\x00\x00\xa7\x00\x97\x00\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xfd\xff\xad\x00\xad\x00\xad\x00\xad\x00\x9f\x00\x9f\x00\x9f\x00\x9f\x00\x9f\x00\x9f\x00\x9f\x00\xb0\x00\x84\x00\x84\x00\x84\x00\x84\x00\x84\x00\x00\x00\x00\x00\x00\x00\x06\x00\xfd\xff\x00\x00\x00\x00\x00\x00\x92\x00\xfd\xff\x0e\x00\xae\x00\x93\x00\x8f\x00\xc2\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x4e\x00\x00\x00\x00\x00\xb1\x00\xb1\x00\xb9\x00\x9e\x00\x98\x00\xac\x00\x00\x00\x79\x00\x68\x00\x00\x00\x00\x00\x77\x00\xfd\xff\x6c\x00\x68\x00\xb2\x00\xff\xff\x6c\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x92\x00\x68\x00\x00\x00\x68\x00\x00\x00\x5a\x00\x68\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00"#
-
-happyGotoOffsets :: HappyAddr
-happyGotoOffsets = HappyA# "\x16\x00\x00\x00\x00\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x62\x00\x52\x00\x48\x00\x6b\x00\x00\x00\x74\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x0e\x02\x0e\x02\x0e\x02\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x04\x86\x03\xae\x05\xdf\x01\x00\x00\x97\x05\xfd\x00\x7f\x05\x00\x00\x9b\x02\x6c\x02\x00\x00\x00\x00\x00\x00\x68\x05\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\xff\x00\x00\x00\x00\x00\x00\x50\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x51\x00\x48\x06\x3e\x06\x32\x06\x28\x06\x12\x06\xfc\x05\x21\x05\xf2\x04\x0a\x05\xdb\x04\xaa\x04\x90\x04\x61\x04\x47\x04\x18\x04\xfe\x03\xcf\x03\x00\x00\x57\x03\x28\x03\xf9\x02\xca\x02\x3d\x02\x00\x00\x00\x00\x00\x00\x09\x00\x08\x06\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x05\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb0\x01\x00\x00\x00\x00\x00\x00\xdc\x05\x31\x00\x81\x01\x39\x05\x28\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x01\x00\x00\x23\x01\x00\x00\xf5\xff\xf4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x05\x00\x00\x00\x00"#
-
-happyDefActions :: HappyAddr
-happyDefActions = HappyA# "\x88\xff\x00\x00\x00\x00\x00\x00\xf2\xff\x87\xff\xee\xff\xec\xff\xea\xff\xeb\xff\xe0\xff\xf7\xff\x82\xff\x82\xff\x82\xff\x00\x00\xf1\xff\x00\x00\x00\x00\xfa\xff\x8c\xff\xda\xff\x7e\xff\xd1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xff\xdd\xff\xdc\xff\xde\xff\xdf\xff\xfd\xff\xe9\xff\x00\x00\xa6\xff\xa5\xff\xa4\xff\x94\xff\x81\xff\xcc\xff\xc8\xff\xc6\xff\xc4\xff\xc2\xff\xc0\xff\xbe\xff\xb5\xff\xb3\xff\xb0\xff\xad\xff\xa9\xff\xa7\xff\xa3\xff\x9f\xff\x9d\xff\x9b\xff\x99\xff\x97\xff\x95\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf4\xff\x00\x00\x00\x00\x00\x00\x90\xff\x00\x00\x00\x00\x91\xff\x8f\xff\x8e\xff\x00\x00\xfc\xff\xfb\xff\xf3\xff\xf5\xff\x00\x00\xd6\xff\xf0\xff\xd5\xff\xd7\xff\xd8\xff\xd9\xff\x00\x00\x8d\xff\x86\xff\xf8\xff\xed\xff\x84\xff\x7d\xff\xac\xff\xca\xff\x00\x00\xcb\xff\x00\x00\x8b\xff\x00\x00\x80\xff\x00\x00\x00\x00\xab\xff\x00\x00\xa3\xff\xaa\xff\xbf\xff\x8c\xff\xb4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\xff\xd4\xff\xd3\xff\xda\xff\x00\x00\xe6\xff\xe5\xff\xe7\xff\xe8\xff\x00\x00\xe4\xff\xc9\xff\xc7\xff\xc5\xff\xc3\xff\xc1\xff\x00\x00\xb7\xff\xb9\xff\xbc\xff\xbb\xff\xba\xff\xbd\xff\xb8\xff\xb1\xff\xb2\xff\xae\xff\xaf\xff\xa0\xff\xa1\xff\x9e\xff\x9c\xff\x9a\xff\x98\xff\x96\xff\x00\x00\x00\x00\x93\xff\xa2\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\xff\x00\x00\x85\xff\x83\xff\xef\xff\x00\x00\xcf\xff\x7f\xff\x92\xff\x00\x00\xcd\xff\x00\x00\xb6\xff\xf0\xff\x00\x00\xe1\xff\xe2\xff\x00\x00\xe3\xff\xf6\xff\xce\xff\xd0\xff\x00\x00\xa8\xff"#
-
-happyCheck :: HappyAddr
-happyCheck = HappyA# "\xff\xff\x0c\x00\x01\x00\x06\x00\x03\x00\x06\x00\x04\x00\x06\x00\x07\x00\x04\x00\x01\x00\x01\x00\x28\x00\x0c\x00\x08\x00\x09\x00\x08\x00\x35\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x19\x00\x0d\x00\x01\x00\x05\x00\x13\x00\x14\x00\x01\x00\x15\x00\x03\x00\x22\x00\x14\x00\x06\x00\x25\x00\x26\x00\x42\x00\x21\x00\x27\x00\x0c\x00\x1c\x00\x12\x00\x2b\x00\x14\x00\x2d\x00\x2e\x00\x2f\x00\x2f\x00\x31\x00\x2e\x00\x33\x00\x04\x00\x0c\x00\x36\x00\x37\x00\x34\x00\x38\x00\x13\x00\x3d\x00\x20\x00\x16\x00\x42\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x27\x00\x3f\x00\x06\x00\x3f\x00\x2b\x00\x33\x00\x2d\x00\x2e\x00\x2f\x00\x01\x00\x31\x00\x03\x00\x33\x00\x01\x00\x06\x00\x36\x00\x37\x00\x04\x00\x08\x00\x04\x00\x0c\x00\x19\x00\x10\x00\x11\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x12\x00\x30\x00\x22\x00\x13\x00\x14\x00\x25\x00\x26\x00\x16\x00\x37\x00\x01\x00\x2a\x00\x03\x00\x0e\x00\x0f\x00\x06\x00\x04\x00\x24\x00\x13\x00\x09\x00\x27\x00\x0c\x00\x0c\x00\x04\x00\x2b\x00\x04\x00\x2d\x00\x2e\x00\x2f\x00\x2b\x00\x31\x00\x36\x00\x33\x00\x2f\x00\x16\x00\x36\x00\x37\x00\x44\x00\x01\x00\x06\x00\x03\x00\x36\x00\x38\x00\x06\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x27\x00\x0c\x00\x0e\x00\x0f\x00\x2b\x00\x3a\x00\x2d\x00\x2e\x00\x2f\x00\x36\x00\x31\x00\x2f\x00\x33\x00\x0a\x00\x0b\x00\x36\x00\x37\x00\x2e\x00\x04\x00\x03\x00\x38\x00\x29\x00\x06\x00\x34\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x0c\x00\x06\x00\x15\x00\x42\x00\x2b\x00\x03\x00\x2d\x00\x3b\x00\x06\x00\x3b\x00\x31\x00\x18\x00\x33\x00\x06\x00\x0c\x00\x36\x00\x37\x00\x10\x00\x04\x00\x0d\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x05\x00\x39\x00\x2c\x00\x2b\x00\x1d\x00\x2d\x00\x30\x00\x28\x00\x3c\x00\x31\x00\x2b\x00\x33\x00\x04\x00\x37\x00\x36\x00\x37\x00\x07\x00\x2b\x00\x42\x00\x0a\x00\x0b\x00\x2c\x00\x2b\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x3b\x00\x07\x00\x37\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x13\x00\x42\x00\x16\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x3b\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x01\x00\x02\x00\x03\x00\x04\x00\x30\x00\x1d\x00\x2c\x00\x38\x00\x34\x00\x35\x00\x30\x00\x3b\x00\x04\x00\x39\x00\x42\x00\x3a\x00\x42\x00\x37\x00\x11\x00\x3f\x00\x10\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x15\x00\x2d\x00\x18\x00\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x04\x00\x2c\x00\x0d\x00\x05\x00\x38\x00\x30\x00\x39\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x37\x00\x0d\x00\x3c\x00\x1d\x00\x11\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x1b\x00\x2d\x00\x42\x00\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\x1c\x00\x23\x00\x42\x00\x44\x00\x38\x00\x3e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x16\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\x38\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\x38\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x16\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x16\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x16\x00\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x16\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x16\x00\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x16\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x16\x00\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x16\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x16\x00\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\x16\x00\xff\xff\x2f\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\xff\xff\xff\xff\x16\x00\x2f\x00\xff\xff\x02\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\xff\xff\x17\x00\x2f\x00\x04\x00\x1a\x00\xff\xff\x1c\x00\xff\xff\x1e\x00\x1f\x00\xff\xff\x38\x00\xff\xff\x04\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\x2c\x00\xff\xff\x2f\x00\x04\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x16\x00\xff\xff\x38\x00\xff\xff\x04\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\xff\xff\xff\xff\x2f\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\xff\xff\x38\x00\x2f\x00\x04\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x38\x00\xff\xff\x04\x00\x2f\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\xff\xff\x38\x00\x2f\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x38\x00\xff\xff\x04\x00\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\x28\x00\x29\x00\x2a\x00\x2b\x00\x16\x00\xff\xff\x38\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x38\x00\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\xff\xff\xff\xff\x38\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
-
-happyTable :: HappyAddr
-happyTable = HappyA# "\x00\x00\xc9\x00\x40\x00\x94\x00\x41\x00\x0d\x00\x14\x00\x42\x00\x43\x00\x59\x00\x52\x00\x8a\x00\x69\x00\x44\x00\x56\x00\x57\x00\x8d\x00\xb6\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0e\x00\x0b\x00\x1b\x00\x03\x00\x94\x00\x54\x00\x40\x00\x8b\x00\x41\x00\x0f\x00\xc6\x00\x42\x00\x10\x00\x11\x00\x14\x00\x58\x00\x45\x00\x44\x00\xc7\x00\x1c\x00\x46\x00\x1d\x00\x47\x00\x48\x00\x49\x00\x16\x00\x4a\x00\x5a\x00\x4b\x00\x64\x00\x5c\x00\x4c\x00\x4d\x00\xb8\x00\x5e\x00\x8b\xff\xbb\x00\x50\x00\x8b\xff\x14\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x45\x00\x23\x00\x0d\x00\x23\x00\x46\x00\x04\x00\x47\x00\x48\x00\x49\x00\x40\x00\x4a\x00\x41\x00\x4b\x00\x52\x00\x42\x00\x4c\x00\x4d\x00\x14\x00\x7a\x00\x23\x00\x44\x00\x0e\x00\xc3\x00\xc4\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x7b\x00\x66\x00\x0f\x00\x53\x00\x54\x00\x10\x00\x11\x00\x28\x00\xbd\x00\x40\x00\x12\x00\x41\x00\x90\x00\x91\x00\x42\x00\x14\x00\x51\x00\x92\x00\x7c\x00\x45\x00\x44\x00\x7d\x00\x59\x00\x46\x00\x12\x00\x47\x00\x48\x00\x49\x00\xac\x00\x4a\x00\x18\x00\x4b\x00\x16\x00\x15\x00\x4c\x00\x4d\x00\xf9\xff\x40\x00\x42\x00\x41\x00\x19\x00\x17\x00\x42\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x45\x00\x44\x00\x8d\x00\x8e\x00\x46\x00\x5e\x00\x47\x00\x48\x00\x49\x00\x1a\x00\x4a\x00\x16\x00\x4b\x00\x78\x00\x79\x00\x4c\x00\x4d\x00\x5a\x00\x64\x00\x41\x00\x17\x00\xcd\x00\x42\x00\x5b\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x44\x00\x42\x00\x74\x00\x14\x00\x46\x00\x41\x00\x47\x00\xc0\x00\x42\x00\xc2\x00\x4a\x00\x75\x00\x4b\x00\x42\x00\x44\x00\x4c\x00\x4d\x00\x73\x00\x76\x00\x77\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x86\x00\x87\x00\xad\x00\x46\x00\x89\x00\x47\x00\x66\x00\x72\x00\x88\x00\x4a\x00\x46\x00\x4b\x00\x64\x00\x67\x00\x4c\x00\x4d\x00\xb0\x00\x46\x00\x14\x00\x78\x00\x79\x00\x9b\x00\x46\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\xaf\x00\xb1\x00\x4d\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\xb3\x00\x14\x00\xb4\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\xb5\x00\x23\x00\x4e\x00\x4f\x00\x14\x00\x25\x00\x26\x00\x27\x00\x14\x00\x1f\x00\x89\x00\xb1\x00\xb6\x00\x20\x00\x21\x00\x66\x00\xb8\x00\x64\x00\x22\x00\x14\x00\x5e\x00\x14\x00\x67\x00\x25\x00\x23\x00\x73\x00\x28\x00\xc8\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x74\x00\x3e\x00\x75\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x76\x00\x65\x00\x77\x00\x86\x00\x17\x00\x66\x00\x87\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x67\x00\xb9\x00\x88\x00\x89\x00\x25\x00\x28\x00\xca\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x8a\x00\x3e\x00\x14\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x59\x00\x52\x00\x14\x00\xff\xff\x17\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\xcb\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\xbc\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\xc0\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x6a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x6b\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x3e\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x95\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x60\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x62\x00\x2c\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x96\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x14\x00\xc2\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x9b\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x14\x00\x9c\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x9d\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x14\x00\x9e\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x9f\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x14\x00\xa0\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x61\x00\x00\x00\x16\x00\x28\x00\x25\x00\x26\x00\x27\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x17\x00\xa1\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x61\x00\x00\x00\x16\x00\x00\x00\x00\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x17\x00\x6f\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x70\x00\x00\x00\x00\x00\x16\x00\x66\x00\x28\x00\x00\x00\x25\x00\x26\x00\x27\x00\x14\x00\x67\x00\x17\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x28\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\xa4\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x00\x00\x28\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\xa3\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x28\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\xa5\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x00\x00\x28\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\xbb\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x28\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x6f\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x00\x00\x28\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x5f\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x28\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x63\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x00\x00\x28\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x69\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x28\x00\x00\x00\x16\x00\x25\x00\x26\x00\x27\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x6c\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x00\x00\x00\x00\x28\x00\x16\x00\x00\x00\x7e\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x00\x00\x7f\x00\x16\x00\x14\x00\x80\x00\x00\x00\x81\x00\x00\x00\x82\x00\x83\x00\x00\x00\x17\x00\x00\x00\x14\x00\xbe\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x84\x00\x00\x00\x16\x00\x14\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x28\x00\x00\x00\x17\x00\x00\x00\x14\x00\xc7\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x00\x00\x00\x00\x16\x00\xa6\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x00\x00\x17\x00\x16\x00\x14\x00\x92\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x17\x00\x00\x00\x14\x00\x16\x00\xa7\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x00\x00\x17\x00\x16\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x00\x00\x00\x17\x00\x00\x00\x14\x00\x00\x00\x00\x00\xa8\x00\x3a\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\xa9\x00\x3b\x00\x3c\x00\x3d\x00\x28\x00\x00\x00\x17\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x3c\x00\x3d\x00\x17\x00\x00\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x00\x3d\x00\x00\x00\x00\x00\x17\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#
-
-happyReduceArr = Happy_Data_Array.array (1, 130) [
-	(1 , happyReduce_1),
-	(2 , happyReduce_2),
-	(3 , happyReduce_3),
-	(4 , happyReduce_4),
-	(5 , happyReduce_5),
-	(6 , happyReduce_6),
-	(7 , happyReduce_7),
-	(8 , happyReduce_8),
-	(9 , happyReduce_9),
-	(10 , happyReduce_10),
-	(11 , happyReduce_11),
-	(12 , happyReduce_12),
-	(13 , happyReduce_13),
-	(14 , happyReduce_14),
-	(15 , happyReduce_15),
-	(16 , happyReduce_16),
-	(17 , happyReduce_17),
-	(18 , happyReduce_18),
-	(19 , happyReduce_19),
-	(20 , happyReduce_20),
-	(21 , happyReduce_21),
-	(22 , happyReduce_22),
-	(23 , happyReduce_23),
-	(24 , happyReduce_24),
-	(25 , happyReduce_25),
-	(26 , happyReduce_26),
-	(27 , happyReduce_27),
-	(28 , happyReduce_28),
-	(29 , happyReduce_29),
-	(30 , happyReduce_30),
-	(31 , happyReduce_31),
-	(32 , happyReduce_32),
-	(33 , happyReduce_33),
-	(34 , happyReduce_34),
-	(35 , happyReduce_35),
-	(36 , happyReduce_36),
-	(37 , happyReduce_37),
-	(38 , happyReduce_38),
-	(39 , happyReduce_39),
-	(40 , happyReduce_40),
-	(41 , happyReduce_41),
-	(42 , happyReduce_42),
-	(43 , happyReduce_43),
-	(44 , happyReduce_44),
-	(45 , happyReduce_45),
-	(46 , happyReduce_46),
-	(47 , happyReduce_47),
-	(48 , happyReduce_48),
-	(49 , happyReduce_49),
-	(50 , happyReduce_50),
-	(51 , happyReduce_51),
-	(52 , happyReduce_52),
-	(53 , happyReduce_53),
-	(54 , happyReduce_54),
-	(55 , happyReduce_55),
-	(56 , happyReduce_56),
-	(57 , happyReduce_57),
-	(58 , happyReduce_58),
-	(59 , happyReduce_59),
-	(60 , happyReduce_60),
-	(61 , happyReduce_61),
-	(62 , happyReduce_62),
-	(63 , happyReduce_63),
-	(64 , happyReduce_64),
-	(65 , happyReduce_65),
-	(66 , happyReduce_66),
-	(67 , happyReduce_67),
-	(68 , happyReduce_68),
-	(69 , happyReduce_69),
-	(70 , happyReduce_70),
-	(71 , happyReduce_71),
-	(72 , happyReduce_72),
-	(73 , happyReduce_73),
-	(74 , happyReduce_74),
-	(75 , happyReduce_75),
-	(76 , happyReduce_76),
-	(77 , happyReduce_77),
-	(78 , happyReduce_78),
-	(79 , happyReduce_79),
-	(80 , happyReduce_80),
-	(81 , happyReduce_81),
-	(82 , happyReduce_82),
-	(83 , happyReduce_83),
-	(84 , happyReduce_84),
-	(85 , happyReduce_85),
-	(86 , happyReduce_86),
-	(87 , happyReduce_87),
-	(88 , happyReduce_88),
-	(89 , happyReduce_89),
-	(90 , happyReduce_90),
-	(91 , happyReduce_91),
-	(92 , happyReduce_92),
-	(93 , happyReduce_93),
-	(94 , happyReduce_94),
-	(95 , happyReduce_95),
-	(96 , happyReduce_96),
-	(97 , happyReduce_97),
-	(98 , happyReduce_98),
-	(99 , happyReduce_99),
-	(100 , happyReduce_100),
-	(101 , happyReduce_101),
-	(102 , happyReduce_102),
-	(103 , happyReduce_103),
-	(104 , happyReduce_104),
-	(105 , happyReduce_105),
-	(106 , happyReduce_106),
-	(107 , happyReduce_107),
-	(108 , happyReduce_108),
-	(109 , happyReduce_109),
-	(110 , happyReduce_110),
-	(111 , happyReduce_111),
-	(112 , happyReduce_112),
-	(113 , happyReduce_113),
-	(114 , happyReduce_114),
-	(115 , happyReduce_115),
-	(116 , happyReduce_116),
-	(117 , happyReduce_117),
-	(118 , happyReduce_118),
-	(119 , happyReduce_119),
-	(120 , happyReduce_120),
-	(121 , happyReduce_121),
-	(122 , happyReduce_122),
-	(123 , happyReduce_123),
-	(124 , happyReduce_124),
-	(125 , happyReduce_125),
-	(126 , happyReduce_126),
-	(127 , happyReduce_127),
-	(128 , happyReduce_128),
-	(129 , happyReduce_129),
-	(130 , happyReduce_130)
-	]
-
-happy_n_terms = 69 :: Int
-happy_n_nonterms = 57 :: Int
-
-happyReduce_1 = happySpecReduce_1  0# happyReduction_1
-happyReduction_1 happy_x_1
-	 =  case happyOutTok happy_x_1 of { (PT _ (TI happy_var_1)) -> 
-	happyIn4
-		 ((read ( happy_var_1)) :: Integer
-	)}
-
-happyReduce_2 = happySpecReduce_1  1# happyReduction_2
-happyReduction_2 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn5
-		 (PosInteger (mkPosToken happy_var_1)
-	)}
-
-happyReduce_3 = happySpecReduce_1  2# happyReduction_3
-happyReduction_3 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn6
-		 (PosDouble (mkPosToken happy_var_1)
-	)}
-
-happyReduce_4 = happySpecReduce_1  3# happyReduction_4
-happyReduction_4 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn7
-		 (PosString (mkPosToken happy_var_1)
-	)}
-
-happyReduce_5 = happySpecReduce_1  4# happyReduction_5
-happyReduction_5 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn8
-		 (PosIdent (mkPosToken happy_var_1)
-	)}
-
-happyReduce_6 = happySpecReduce_1  5# happyReduction_6
-happyReduction_6 happy_x_1
-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> 
-	happyIn9
-		 (Module (reverse happy_var_1)
-	)}
-
-happyReduce_7 = happyReduce 4# 6# happyReduction_7
-happyReduction_7 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut8 happy_x_2 of { happy_var_2 -> 
-	case happyOut56 happy_x_4 of { happy_var_4 -> 
-	happyIn10
-		 (PosEnumDecl (gp happy_var_1) happy_var_2 happy_var_4
-	) `HappyStk` happyRest}}}
-
-happyReduce_8 = happySpecReduce_1  6# happyReduction_8
-happyReduction_8 happy_x_1
-	 =  case happyOut17 happy_x_1 of { happy_var_1 -> 
-	happyIn10
-		 (ElementDecl happy_var_1
-	)}
-
-happyReduce_9 = happyReduce 7# 7# happyReduction_9
-happyReduction_9 (happy_x_7 `HappyStk`
-	happy_x_6 `HappyStk`
-	happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut15 happy_x_1 of { happy_var_1 -> 
-	case happyOut22 happy_x_2 of { happy_var_2 -> 
-	case happyOut8 happy_x_3 of { happy_var_3 -> 
-	case happyOut18 happy_x_4 of { happy_var_4 -> 
-	case happyOut23 happy_x_5 of { happy_var_5 -> 
-	case happyOut20 happy_x_6 of { happy_var_6 -> 
-	case happyOut16 happy_x_7 of { happy_var_7 -> 
-	happyIn11
-		 (Clafer happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_5 happy_var_6 happy_var_7
-	) `HappyStk` happyRest}}}}}}}
-
-happyReduce_10 = happySpecReduce_3  8# happyReduction_10
-happyReduction_10 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut58 happy_x_2 of { happy_var_2 -> 
-	happyIn12
-		 (PosConstraint (gp happy_var_1) (reverse happy_var_2)
-	)}}
-
-happyReduce_11 = happySpecReduce_3  9# happyReduction_11
-happyReduction_11 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut58 happy_x_2 of { happy_var_2 -> 
-	happyIn13
-		 (PosSoftConstraint (gp happy_var_1) (reverse happy_var_2)
-	)}}
-
-happyReduce_12 = happySpecReduce_3  10# happyReduction_12
-happyReduction_12 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut58 happy_x_2 of { happy_var_2 -> 
-	happyIn14
-		 (PosGoal (gp happy_var_1) (reverse happy_var_2)
-	)}}
-
-happyReduce_13 = happySpecReduce_0  11# happyReduction_13
-happyReduction_13  =  happyIn15
-		 (AbstractEmpty
-	)
-
-happyReduce_14 = happySpecReduce_1  11# happyReduction_14
-happyReduction_14 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn15
-		 (PosAbstract (gp happy_var_1)
-	)}
-
-happyReduce_15 = happySpecReduce_0  12# happyReduction_15
-happyReduction_15  =  happyIn16
-		 (ElementsEmpty
-	)
-
-happyReduce_16 = happySpecReduce_3  12# happyReduction_16
-happyReduction_16 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut57 happy_x_2 of { happy_var_2 -> 
-	happyIn16
-		 (PosElementsList (gp happy_var_1) (reverse happy_var_2)
-	)}}
-
-happyReduce_17 = happySpecReduce_1  13# happyReduction_17
-happyReduction_17 happy_x_1
-	 =  case happyOut11 happy_x_1 of { happy_var_1 -> 
-	happyIn17
-		 (Subclafer happy_var_1
-	)}
-
-happyReduce_18 = happyReduce 4# 13# happyReduction_18
-happyReduction_18 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut26 happy_x_2 of { happy_var_2 -> 
-	case happyOut23 happy_x_3 of { happy_var_3 -> 
-	case happyOut16 happy_x_4 of { happy_var_4 -> 
-	happyIn17
-		 (PosClaferUse (gp happy_var_1) happy_var_2 happy_var_3 happy_var_4
-	) `HappyStk` happyRest}}}}
-
-happyReduce_19 = happySpecReduce_1  13# happyReduction_19
-happyReduction_19 happy_x_1
-	 =  case happyOut12 happy_x_1 of { happy_var_1 -> 
-	happyIn17
-		 (Subconstraint happy_var_1
-	)}
-
-happyReduce_20 = happySpecReduce_1  13# happyReduction_20
-happyReduction_20 happy_x_1
-	 =  case happyOut14 happy_x_1 of { happy_var_1 -> 
-	happyIn17
-		 (Subgoal happy_var_1
-	)}
-
-happyReduce_21 = happySpecReduce_1  13# happyReduction_21
-happyReduction_21 happy_x_1
-	 =  case happyOut13 happy_x_1 of { happy_var_1 -> 
-	happyIn17
-		 (Subsoftconstraint happy_var_1
-	)}
-
-happyReduce_22 = happySpecReduce_0  14# happyReduction_22
-happyReduction_22  =  happyIn18
-		 (SuperEmpty
-	)
-
-happyReduce_23 = happySpecReduce_2  14# happyReduction_23
-happyReduction_23 happy_x_2
-	happy_x_1
-	 =  case happyOut19 happy_x_1 of { happy_var_1 -> 
-	case happyOut41 happy_x_2 of { happy_var_2 -> 
-	happyIn18
-		 (SuperSome happy_var_1 happy_var_2
-	)}}
-
-happyReduce_24 = happySpecReduce_1  15# happyReduction_24
-happyReduction_24 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn19
-		 (PosSuperColon (gp happy_var_1)
-	)}
-
-happyReduce_25 = happySpecReduce_1  15# happyReduction_25
-happyReduction_25 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn19
-		 (PosSuperArrow (gp happy_var_1)
-	)}
-
-happyReduce_26 = happySpecReduce_1  15# happyReduction_26
-happyReduction_26 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn19
-		 (PosSuperMArrow (gp happy_var_1)
-	)}
-
-happyReduce_27 = happySpecReduce_0  16# happyReduction_27
-happyReduction_27  =  happyIn20
-		 (InitEmpty
-	)
-
-happyReduce_28 = happySpecReduce_2  16# happyReduction_28
-happyReduction_28 happy_x_2
-	happy_x_1
-	 =  case happyOut21 happy_x_1 of { happy_var_1 -> 
-	case happyOut27 happy_x_2 of { happy_var_2 -> 
-	happyIn20
-		 (InitSome happy_var_1 happy_var_2
-	)}}
-
-happyReduce_29 = happySpecReduce_1  17# happyReduction_29
-happyReduction_29 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn21
-		 (PosInitHow_1 (gp happy_var_1)
-	)}
-
-happyReduce_30 = happySpecReduce_1  17# happyReduction_30
-happyReduction_30 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn21
-		 (PosInitHow_2 (gp happy_var_1)
-	)}
-
-happyReduce_31 = happySpecReduce_0  18# happyReduction_31
-happyReduction_31  =  happyIn22
-		 (GCardEmpty
-	)
-
-happyReduce_32 = happySpecReduce_1  18# happyReduction_32
-happyReduction_32 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn22
-		 (PosGCardXor (gp happy_var_1)
-	)}
-
-happyReduce_33 = happySpecReduce_1  18# happyReduction_33
-happyReduction_33 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn22
-		 (PosGCardOr (gp happy_var_1)
-	)}
-
-happyReduce_34 = happySpecReduce_1  18# happyReduction_34
-happyReduction_34 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn22
-		 (PosGCardMux (gp happy_var_1)
-	)}
-
-happyReduce_35 = happySpecReduce_1  18# happyReduction_35
-happyReduction_35 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn22
-		 (PosGCardOpt (gp happy_var_1)
-	)}
-
-happyReduce_36 = happySpecReduce_1  18# happyReduction_36
-happyReduction_36 happy_x_1
-	 =  case happyOut24 happy_x_1 of { happy_var_1 -> 
-	happyIn22
-		 (GCardInterval happy_var_1
-	)}
-
-happyReduce_37 = happySpecReduce_0  19# happyReduction_37
-happyReduction_37  =  happyIn23
-		 (CardEmpty
-	)
-
-happyReduce_38 = happySpecReduce_1  19# happyReduction_38
-happyReduction_38 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn23
-		 (PosCardLone (gp happy_var_1)
-	)}
-
-happyReduce_39 = happySpecReduce_1  19# happyReduction_39
-happyReduction_39 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn23
-		 (PosCardSome (gp happy_var_1)
-	)}
-
-happyReduce_40 = happySpecReduce_1  19# happyReduction_40
-happyReduction_40 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn23
-		 (PosCardAny (gp happy_var_1)
-	)}
-
-happyReduce_41 = happySpecReduce_1  19# happyReduction_41
-happyReduction_41 happy_x_1
-	 =  case happyOut5 happy_x_1 of { happy_var_1 -> 
-	happyIn23
-		 (CardNum happy_var_1
-	)}
-
-happyReduce_42 = happySpecReduce_1  19# happyReduction_42
-happyReduction_42 happy_x_1
-	 =  case happyOut24 happy_x_1 of { happy_var_1 -> 
-	happyIn23
-		 (CardInterval happy_var_1
-	)}
-
-happyReduce_43 = happySpecReduce_3  20# happyReduction_43
-happyReduction_43 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut5 happy_x_1 of { happy_var_1 -> 
-	case happyOut25 happy_x_3 of { happy_var_3 -> 
-	happyIn24
-		 (NCard happy_var_1 happy_var_3
-	)}}
-
-happyReduce_44 = happySpecReduce_1  21# happyReduction_44
-happyReduction_44 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn25
-		 (PosExIntegerAst (gp happy_var_1)
-	)}
-
-happyReduce_45 = happySpecReduce_1  21# happyReduction_45
-happyReduction_45 happy_x_1
-	 =  case happyOut5 happy_x_1 of { happy_var_1 -> 
-	happyIn25
-		 (ExIntegerNum happy_var_1
-	)}
-
-happyReduce_46 = happySpecReduce_1  22# happyReduction_46
-happyReduction_46 happy_x_1
-	 =  case happyOut60 happy_x_1 of { happy_var_1 -> 
-	happyIn26
-		 (Path happy_var_1
-	)}
-
-happyReduce_47 = happyReduce 5# 23# happyReduction_47
-happyReduction_47 (happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut48 happy_x_3 of { happy_var_3 -> 
-	case happyOut27 happy_x_5 of { happy_var_5 -> 
-	happyIn27
-		 (PosDeclAllDisj (gp happy_var_1) happy_var_3 happy_var_5
-	) `HappyStk` happyRest}}}
-
-happyReduce_48 = happyReduce 4# 23# happyReduction_48
-happyReduction_48 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut48 happy_x_2 of { happy_var_2 -> 
-	case happyOut27 happy_x_4 of { happy_var_4 -> 
-	happyIn27
-		 (PosDeclAll (gp happy_var_1) happy_var_2 happy_var_4
-	) `HappyStk` happyRest}}}
-
-happyReduce_49 = happyReduce 5# 23# happyReduction_49
-happyReduction_49 (happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut49 happy_x_1 of { happy_var_1 -> 
-	case happyOut48 happy_x_3 of { happy_var_3 -> 
-	case happyOut27 happy_x_5 of { happy_var_5 -> 
-	happyIn27
-		 (DeclQuantDisj happy_var_1 happy_var_3 happy_var_5
-	) `HappyStk` happyRest}}}
-
-happyReduce_50 = happyReduce 4# 23# happyReduction_50
-happyReduction_50 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut49 happy_x_1 of { happy_var_1 -> 
-	case happyOut48 happy_x_2 of { happy_var_2 -> 
-	case happyOut27 happy_x_4 of { happy_var_4 -> 
-	happyIn27
-		 (DeclQuant happy_var_1 happy_var_2 happy_var_4
-	) `HappyStk` happyRest}}}
-
-happyReduce_51 = happySpecReduce_1  23# happyReduction_51
-happyReduction_51 happy_x_1
-	 =  case happyOut28 happy_x_1 of { happy_var_1 -> 
-	happyIn27
-		 (happy_var_1
-	)}
-
-happyReduce_52 = happySpecReduce_2  24# happyReduction_52
-happyReduction_52 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut29 happy_x_2 of { happy_var_2 -> 
-	happyIn28
-		 (PosEGMax (gp happy_var_1) happy_var_2
-	)}}
-
-happyReduce_53 = happySpecReduce_2  24# happyReduction_53
-happyReduction_53 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut29 happy_x_2 of { happy_var_2 -> 
-	happyIn28
-		 (PosEGMin (gp happy_var_1) happy_var_2
-	)}}
-
-happyReduce_54 = happySpecReduce_3  24# happyReduction_54
-happyReduction_54 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut28 happy_x_1 of { happy_var_1 -> 
-	case happyOut29 happy_x_3 of { happy_var_3 -> 
-	happyIn28
-		 (EIff happy_var_1 happy_var_3
-	)}}
-
-happyReduce_55 = happySpecReduce_1  24# happyReduction_55
-happyReduction_55 happy_x_1
-	 =  case happyOut29 happy_x_1 of { happy_var_1 -> 
-	happyIn28
-		 (happy_var_1
-	)}
-
-happyReduce_56 = happySpecReduce_3  25# happyReduction_56
-happyReduction_56 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut29 happy_x_1 of { happy_var_1 -> 
-	case happyOut30 happy_x_3 of { happy_var_3 -> 
-	happyIn29
-		 (EImplies happy_var_1 happy_var_3
-	)}}
-
-happyReduce_57 = happySpecReduce_1  25# happyReduction_57
-happyReduction_57 happy_x_1
-	 =  case happyOut30 happy_x_1 of { happy_var_1 -> 
-	happyIn29
-		 (happy_var_1
-	)}
-
-happyReduce_58 = happySpecReduce_3  26# happyReduction_58
-happyReduction_58 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut30 happy_x_1 of { happy_var_1 -> 
-	case happyOut31 happy_x_3 of { happy_var_3 -> 
-	happyIn30
-		 (EOr happy_var_1 happy_var_3
-	)}}
-
-happyReduce_59 = happySpecReduce_1  26# happyReduction_59
-happyReduction_59 happy_x_1
-	 =  case happyOut31 happy_x_1 of { happy_var_1 -> 
-	happyIn30
-		 (happy_var_1
-	)}
-
-happyReduce_60 = happySpecReduce_3  27# happyReduction_60
-happyReduction_60 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut31 happy_x_1 of { happy_var_1 -> 
-	case happyOut32 happy_x_3 of { happy_var_3 -> 
-	happyIn31
-		 (EXor happy_var_1 happy_var_3
-	)}}
-
-happyReduce_61 = happySpecReduce_1  27# happyReduction_61
-happyReduction_61 happy_x_1
-	 =  case happyOut32 happy_x_1 of { happy_var_1 -> 
-	happyIn31
-		 (happy_var_1
-	)}
-
-happyReduce_62 = happySpecReduce_3  28# happyReduction_62
-happyReduction_62 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut32 happy_x_1 of { happy_var_1 -> 
-	case happyOut33 happy_x_3 of { happy_var_3 -> 
-	happyIn32
-		 (EAnd happy_var_1 happy_var_3
-	)}}
-
-happyReduce_63 = happySpecReduce_1  28# happyReduction_63
-happyReduction_63 happy_x_1
-	 =  case happyOut33 happy_x_1 of { happy_var_1 -> 
-	happyIn32
-		 (happy_var_1
-	)}
-
-happyReduce_64 = happySpecReduce_2  29# happyReduction_64
-happyReduction_64 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut34 happy_x_2 of { happy_var_2 -> 
-	happyIn33
-		 (PosENeg (gp happy_var_1) happy_var_2
-	)}}
-
-happyReduce_65 = happySpecReduce_1  29# happyReduction_65
-happyReduction_65 happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	happyIn33
-		 (happy_var_1
-	)}
-
-happyReduce_66 = happySpecReduce_3  30# happyReduction_66
-happyReduction_66 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (ELt happy_var_1 happy_var_3
-	)}}
-
-happyReduce_67 = happySpecReduce_3  30# happyReduction_67
-happyReduction_67 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (EGt happy_var_1 happy_var_3
-	)}}
-
-happyReduce_68 = happySpecReduce_3  30# happyReduction_68
-happyReduction_68 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (EEq happy_var_1 happy_var_3
-	)}}
-
-happyReduce_69 = happySpecReduce_3  30# happyReduction_69
-happyReduction_69 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (ELte happy_var_1 happy_var_3
-	)}}
-
-happyReduce_70 = happySpecReduce_3  30# happyReduction_70
-happyReduction_70 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (EGte happy_var_1 happy_var_3
-	)}}
-
-happyReduce_71 = happySpecReduce_3  30# happyReduction_71
-happyReduction_71 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (ENeq happy_var_1 happy_var_3
-	)}}
-
-happyReduce_72 = happySpecReduce_3  30# happyReduction_72
-happyReduction_72 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_3 of { happy_var_3 -> 
-	happyIn34
-		 (EIn happy_var_1 happy_var_3
-	)}}
-
-happyReduce_73 = happyReduce 4# 30# happyReduction_73
-happyReduction_73 (happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOut34 happy_x_1 of { happy_var_1 -> 
-	case happyOut35 happy_x_4 of { happy_var_4 -> 
-	happyIn34
-		 (ENin happy_var_1 happy_var_4
-	) `HappyStk` happyRest}}
-
-happyReduce_74 = happySpecReduce_1  30# happyReduction_74
-happyReduction_74 happy_x_1
-	 =  case happyOut35 happy_x_1 of { happy_var_1 -> 
-	happyIn34
-		 (happy_var_1
-	)}
-
-happyReduce_75 = happySpecReduce_2  31# happyReduction_75
-happyReduction_75 happy_x_2
-	happy_x_1
-	 =  case happyOut49 happy_x_1 of { happy_var_1 -> 
-	case happyOut39 happy_x_2 of { happy_var_2 -> 
-	happyIn35
-		 (QuantExp happy_var_1 happy_var_2
-	)}}
-
-happyReduce_76 = happySpecReduce_1  31# happyReduction_76
-happyReduction_76 happy_x_1
-	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
-	happyIn35
-		 (happy_var_1
-	)}
-
-happyReduce_77 = happySpecReduce_3  32# happyReduction_77
-happyReduction_77 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
-	case happyOut37 happy_x_3 of { happy_var_3 -> 
-	happyIn36
-		 (EAdd happy_var_1 happy_var_3
-	)}}
-
-happyReduce_78 = happySpecReduce_3  32# happyReduction_78
-happyReduction_78 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut36 happy_x_1 of { happy_var_1 -> 
-	case happyOut37 happy_x_3 of { happy_var_3 -> 
-	happyIn36
-		 (ESub happy_var_1 happy_var_3
-	)}}
-
-happyReduce_79 = happySpecReduce_1  32# happyReduction_79
-happyReduction_79 happy_x_1
-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> 
-	happyIn36
-		 (happy_var_1
-	)}
-
-happyReduce_80 = happySpecReduce_3  33# happyReduction_80
-happyReduction_80 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> 
-	case happyOut38 happy_x_3 of { happy_var_3 -> 
-	happyIn37
-		 (EMul happy_var_1 happy_var_3
-	)}}
-
-happyReduce_81 = happySpecReduce_3  33# happyReduction_81
-happyReduction_81 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut37 happy_x_1 of { happy_var_1 -> 
-	case happyOut38 happy_x_3 of { happy_var_3 -> 
-	happyIn37
-		 (EDiv happy_var_1 happy_var_3
-	)}}
-
-happyReduce_82 = happySpecReduce_1  33# happyReduction_82
-happyReduction_82 happy_x_1
-	 =  case happyOut38 happy_x_1 of { happy_var_1 -> 
-	happyIn37
-		 (happy_var_1
-	)}
-
-happyReduce_83 = happySpecReduce_2  34# happyReduction_83
-happyReduction_83 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut39 happy_x_2 of { happy_var_2 -> 
-	happyIn38
-		 (PosESumSetExp (gp happy_var_1) happy_var_2
-	)}}
-
-happyReduce_84 = happySpecReduce_2  34# happyReduction_84
-happyReduction_84 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut39 happy_x_2 of { happy_var_2 -> 
-	happyIn38
-		 (PosEMinExp (gp happy_var_1) happy_var_2
-	)}}
-
-happyReduce_85 = happySpecReduce_2  34# happyReduction_85
-happyReduction_85 happy_x_2
-	happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut39 happy_x_2 of { happy_var_2 -> 
-	happyIn38
-		 (PosECSetExp (gp happy_var_1) happy_var_2
-	)}}
-
-happyReduce_86 = happySpecReduce_1  34# happyReduction_86
-happyReduction_86 happy_x_1
-	 =  case happyOut39 happy_x_1 of { happy_var_1 -> 
-	happyIn38
-		 (happy_var_1
-	)}
-
-happyReduce_87 = happyReduce 6# 35# happyReduction_87
-happyReduction_87 (happy_x_6 `HappyStk`
-	happy_x_5 `HappyStk`
-	happy_x_4 `HappyStk`
-	happy_x_3 `HappyStk`
-	happy_x_2 `HappyStk`
-	happy_x_1 `HappyStk`
-	happyRest)
-	 = case happyOutTok happy_x_1 of { happy_var_1 -> 
-	case happyOut39 happy_x_2 of { happy_var_2 -> 
-	case happyOut39 happy_x_4 of { happy_var_4 -> 
-	case happyOut40 happy_x_6 of { happy_var_6 -> 
-	happyIn39
-		 (PosEImpliesElse (gp happy_var_1) happy_var_2 happy_var_4 happy_var_6
-	) `HappyStk` happyRest}}}}
-
-happyReduce_88 = happySpecReduce_1  35# happyReduction_88
-happyReduction_88 happy_x_1
-	 =  case happyOut40 happy_x_1 of { happy_var_1 -> 
-	happyIn39
-		 (happy_var_1
-	)}
-
-happyReduce_89 = happySpecReduce_1  36# happyReduction_89
-happyReduction_89 happy_x_1
-	 =  case happyOut5 happy_x_1 of { happy_var_1 -> 
-	happyIn40
-		 (EInt happy_var_1
-	)}
-
-happyReduce_90 = happySpecReduce_1  36# happyReduction_90
-happyReduction_90 happy_x_1
-	 =  case happyOut6 happy_x_1 of { happy_var_1 -> 
-	happyIn40
-		 (EDouble happy_var_1
-	)}
-
-happyReduce_91 = happySpecReduce_1  36# happyReduction_91
-happyReduction_91 happy_x_1
-	 =  case happyOut7 happy_x_1 of { happy_var_1 -> 
-	happyIn40
-		 (EStr happy_var_1
-	)}
-
-happyReduce_92 = happySpecReduce_1  36# happyReduction_92
-happyReduction_92 happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	happyIn40
-		 (ESetExp happy_var_1
-	)}
-
-happyReduce_93 = happySpecReduce_3  36# happyReduction_93
-happyReduction_93 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut27 happy_x_2 of { happy_var_2 -> 
-	happyIn40
-		 (happy_var_2
-	)}
-
-happyReduce_94 = happySpecReduce_3  37# happyReduction_94
-happyReduction_94 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (Union happy_var_1 happy_var_3
-	)}}
-
-happyReduce_95 = happySpecReduce_3  37# happyReduction_95
-happyReduction_95 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_1 of { happy_var_1 -> 
-	case happyOut42 happy_x_3 of { happy_var_3 -> 
-	happyIn41
-		 (UnionCom happy_var_1 happy_var_3
-	)}}
-
-happyReduce_96 = happySpecReduce_1  37# happyReduction_96
-happyReduction_96 happy_x_1
-	 =  case happyOut42 happy_x_1 of { happy_var_1 -> 
-	happyIn41
-		 (happy_var_1
-	)}
-
-happyReduce_97 = happySpecReduce_3  38# happyReduction_97
-happyReduction_97 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut42 happy_x_1 of { happy_var_1 -> 
-	case happyOut43 happy_x_3 of { happy_var_3 -> 
-	happyIn42
-		 (Difference happy_var_1 happy_var_3
-	)}}
-
-happyReduce_98 = happySpecReduce_1  38# happyReduction_98
-happyReduction_98 happy_x_1
-	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
-	happyIn42
-		 (happy_var_1
-	)}
-
-happyReduce_99 = happySpecReduce_3  39# happyReduction_99
-happyReduction_99 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut43 happy_x_1 of { happy_var_1 -> 
-	case happyOut44 happy_x_3 of { happy_var_3 -> 
-	happyIn43
-		 (Intersection happy_var_1 happy_var_3
-	)}}
-
-happyReduce_100 = happySpecReduce_1  39# happyReduction_100
-happyReduction_100 happy_x_1
-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
-	happyIn43
-		 (happy_var_1
-	)}
-
-happyReduce_101 = happySpecReduce_3  40# happyReduction_101
-happyReduction_101 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut44 happy_x_1 of { happy_var_1 -> 
-	case happyOut45 happy_x_3 of { happy_var_3 -> 
-	happyIn44
-		 (Domain happy_var_1 happy_var_3
-	)}}
-
-happyReduce_102 = happySpecReduce_1  40# happyReduction_102
-happyReduction_102 happy_x_1
-	 =  case happyOut45 happy_x_1 of { happy_var_1 -> 
-	happyIn44
-		 (happy_var_1
-	)}
-
-happyReduce_103 = happySpecReduce_3  41# happyReduction_103
-happyReduction_103 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut45 happy_x_1 of { happy_var_1 -> 
-	case happyOut46 happy_x_3 of { happy_var_3 -> 
-	happyIn45
-		 (Range happy_var_1 happy_var_3
-	)}}
-
-happyReduce_104 = happySpecReduce_1  41# happyReduction_104
-happyReduction_104 happy_x_1
-	 =  case happyOut46 happy_x_1 of { happy_var_1 -> 
-	happyIn45
-		 (happy_var_1
-	)}
-
-happyReduce_105 = happySpecReduce_3  42# happyReduction_105
-happyReduction_105 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut46 happy_x_1 of { happy_var_1 -> 
-	case happyOut47 happy_x_3 of { happy_var_3 -> 
-	happyIn46
-		 (Join happy_var_1 happy_var_3
-	)}}
-
-happyReduce_106 = happySpecReduce_1  42# happyReduction_106
-happyReduction_106 happy_x_1
-	 =  case happyOut47 happy_x_1 of { happy_var_1 -> 
-	happyIn46
-		 (happy_var_1
-	)}
-
-happyReduce_107 = happySpecReduce_1  43# happyReduction_107
-happyReduction_107 happy_x_1
-	 =  case happyOut26 happy_x_1 of { happy_var_1 -> 
-	happyIn47
-		 (ClaferId happy_var_1
-	)}
-
-happyReduce_108 = happySpecReduce_3  43# happyReduction_108
-happyReduction_108 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut41 happy_x_2 of { happy_var_2 -> 
-	happyIn47
-		 (happy_var_2
-	)}
-
-happyReduce_109 = happySpecReduce_3  44# happyReduction_109
-happyReduction_109 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut59 happy_x_1 of { happy_var_1 -> 
-	case happyOut41 happy_x_3 of { happy_var_3 -> 
-	happyIn48
-		 (Decl happy_var_1 happy_var_3
-	)}}
-
-happyReduce_110 = happySpecReduce_1  45# happyReduction_110
-happyReduction_110 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn49
-		 (PosQuantNo (gp happy_var_1)
-	)}
-
-happyReduce_111 = happySpecReduce_1  45# happyReduction_111
-happyReduction_111 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn49
-		 (PosQuantLone (gp happy_var_1)
-	)}
-
-happyReduce_112 = happySpecReduce_1  45# happyReduction_112
-happyReduction_112 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn49
-		 (PosQuantOne (gp happy_var_1)
-	)}
-
-happyReduce_113 = happySpecReduce_1  45# happyReduction_113
-happyReduction_113 happy_x_1
-	 =  case happyOutTok happy_x_1 of { happy_var_1 -> 
-	happyIn49
-		 (PosQuantSome (gp happy_var_1)
-	)}
-
-happyReduce_114 = happySpecReduce_1  46# happyReduction_114
-happyReduction_114 happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	happyIn50
-		 (EnumIdIdent happy_var_1
-	)}
-
-happyReduce_115 = happySpecReduce_1  47# happyReduction_115
-happyReduction_115 happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	happyIn51
-		 (ModIdIdent happy_var_1
-	)}
-
-happyReduce_116 = happySpecReduce_1  48# happyReduction_116
-happyReduction_116 happy_x_1
-	 =  case happyOut8 happy_x_1 of { happy_var_1 -> 
-	happyIn52
-		 (LocIdIdent happy_var_1
-	)}
-
-happyReduce_117 = happySpecReduce_2  49# happyReduction_117
-happyReduction_117 happy_x_2
-	happy_x_1
-	 =  case happyOut4 happy_x_1 of { happy_var_1 -> 
-	case happyOut4 happy_x_2 of { happy_var_2 -> 
-	happyIn53
-		 (Pos happy_var_1 happy_var_2
-	)}}
-
-happyReduce_118 = happySpecReduce_2  50# happyReduction_118
-happyReduction_118 happy_x_2
-	happy_x_1
-	 =  case happyOut53 happy_x_1 of { happy_var_1 -> 
-	case happyOut53 happy_x_2 of { happy_var_2 -> 
-	happyIn54
-		 (Span happy_var_1 happy_var_2
-	)}}
-
-happyReduce_119 = happySpecReduce_0  51# happyReduction_119
-happyReduction_119  =  happyIn55
-		 ([]
-	)
-
-happyReduce_120 = happySpecReduce_2  51# happyReduction_120
-happyReduction_120 happy_x_2
-	happy_x_1
-	 =  case happyOut55 happy_x_1 of { happy_var_1 -> 
-	case happyOut10 happy_x_2 of { happy_var_2 -> 
-	happyIn55
-		 (flip (:) happy_var_1 happy_var_2
-	)}}
-
-happyReduce_121 = happySpecReduce_1  52# happyReduction_121
-happyReduction_121 happy_x_1
-	 =  case happyOut50 happy_x_1 of { happy_var_1 -> 
-	happyIn56
-		 ((:[]) happy_var_1
-	)}
-
-happyReduce_122 = happySpecReduce_3  52# happyReduction_122
-happyReduction_122 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut50 happy_x_1 of { happy_var_1 -> 
-	case happyOut56 happy_x_3 of { happy_var_3 -> 
-	happyIn56
-		 ((:) happy_var_1 happy_var_3
-	)}}
-
-happyReduce_123 = happySpecReduce_0  53# happyReduction_123
-happyReduction_123  =  happyIn57
-		 ([]
-	)
-
-happyReduce_124 = happySpecReduce_2  53# happyReduction_124
-happyReduction_124 happy_x_2
-	happy_x_1
-	 =  case happyOut57 happy_x_1 of { happy_var_1 -> 
-	case happyOut17 happy_x_2 of { happy_var_2 -> 
-	happyIn57
-		 (flip (:) happy_var_1 happy_var_2
-	)}}
-
-happyReduce_125 = happySpecReduce_0  54# happyReduction_125
-happyReduction_125  =  happyIn58
-		 ([]
-	)
-
-happyReduce_126 = happySpecReduce_2  54# happyReduction_126
-happyReduction_126 happy_x_2
-	happy_x_1
-	 =  case happyOut58 happy_x_1 of { happy_var_1 -> 
-	case happyOut27 happy_x_2 of { happy_var_2 -> 
-	happyIn58
-		 (flip (:) happy_var_1 happy_var_2
-	)}}
-
-happyReduce_127 = happySpecReduce_1  55# happyReduction_127
-happyReduction_127 happy_x_1
-	 =  case happyOut52 happy_x_1 of { happy_var_1 -> 
-	happyIn59
-		 ((:[]) happy_var_1
-	)}
-
-happyReduce_128 = happySpecReduce_3  55# happyReduction_128
-happyReduction_128 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut52 happy_x_1 of { happy_var_1 -> 
-	case happyOut59 happy_x_3 of { happy_var_3 -> 
-	happyIn59
-		 ((:) happy_var_1 happy_var_3
-	)}}
-
-happyReduce_129 = happySpecReduce_1  56# happyReduction_129
-happyReduction_129 happy_x_1
-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
-	happyIn60
-		 ((:[]) happy_var_1
-	)}
-
-happyReduce_130 = happySpecReduce_3  56# happyReduction_130
-happyReduction_130 happy_x_3
-	happy_x_2
-	happy_x_1
-	 =  case happyOut51 happy_x_1 of { happy_var_1 -> 
-	case happyOut60 happy_x_3 of { happy_var_3 -> 
-	happyIn60
-		 ((:) happy_var_1 happy_var_3
-	)}}
-
-happyNewToken action sts stk [] =
-	happyDoAction 68# notHappyAtAll action sts stk []
-
-happyNewToken action sts stk (tk:tks) =
-	let cont i = happyDoAction i tk action sts stk tks in
-	case tk of {
-	PT _ (TS _ 1) -> cont 1#;
-	PT _ (TS _ 2) -> cont 2#;
-	PT _ (TS _ 3) -> cont 3#;
-	PT _ (TS _ 4) -> cont 4#;
-	PT _ (TS _ 5) -> cont 5#;
-	PT _ (TS _ 6) -> cont 6#;
-	PT _ (TS _ 7) -> cont 7#;
-	PT _ (TS _ 8) -> cont 8#;
-	PT _ (TS _ 9) -> cont 9#;
-	PT _ (TS _ 10) -> cont 10#;
-	PT _ (TS _ 11) -> cont 11#;
-	PT _ (TS _ 12) -> cont 12#;
-	PT _ (TS _ 13) -> cont 13#;
-	PT _ (TS _ 14) -> cont 14#;
-	PT _ (TS _ 15) -> cont 15#;
-	PT _ (TS _ 16) -> cont 16#;
-	PT _ (TS _ 17) -> cont 17#;
-	PT _ (TS _ 18) -> cont 18#;
-	PT _ (TS _ 19) -> cont 19#;
-	PT _ (TS _ 20) -> cont 20#;
-	PT _ (TS _ 21) -> cont 21#;
-	PT _ (TS _ 22) -> cont 22#;
-	PT _ (TS _ 23) -> cont 23#;
-	PT _ (TS _ 24) -> cont 24#;
-	PT _ (TS _ 25) -> cont 25#;
-	PT _ (TS _ 26) -> cont 26#;
-	PT _ (TS _ 27) -> cont 27#;
-	PT _ (TS _ 28) -> cont 28#;
-	PT _ (TS _ 29) -> cont 29#;
-	PT _ (TS _ 30) -> cont 30#;
-	PT _ (TS _ 31) -> cont 31#;
-	PT _ (TS _ 32) -> cont 32#;
-	PT _ (TS _ 33) -> cont 33#;
-	PT _ (TS _ 34) -> cont 34#;
-	PT _ (TS _ 35) -> cont 35#;
-	PT _ (TS _ 36) -> cont 36#;
-	PT _ (TS _ 37) -> cont 37#;
-	PT _ (TS _ 38) -> cont 38#;
-	PT _ (TS _ 39) -> cont 39#;
-	PT _ (TS _ 40) -> cont 40#;
-	PT _ (TS _ 41) -> cont 41#;
-	PT _ (TS _ 42) -> cont 42#;
-	PT _ (TS _ 43) -> cont 43#;
-	PT _ (TS _ 44) -> cont 44#;
-	PT _ (TS _ 45) -> cont 45#;
-	PT _ (TS _ 46) -> cont 46#;
-	PT _ (TS _ 47) -> cont 47#;
-	PT _ (TS _ 48) -> cont 48#;
-	PT _ (TS _ 49) -> cont 49#;
-	PT _ (TS _ 50) -> cont 50#;
-	PT _ (TS _ 51) -> cont 51#;
-	PT _ (TS _ 52) -> cont 52#;
-	PT _ (TS _ 53) -> cont 53#;
-	PT _ (TS _ 54) -> cont 54#;
-	PT _ (TS _ 55) -> cont 55#;
-	PT _ (TS _ 56) -> cont 56#;
-	PT _ (TS _ 57) -> cont 57#;
-	PT _ (TS _ 58) -> cont 58#;
-	PT _ (TS _ 59) -> cont 59#;
-	PT _ (TS _ 60) -> cont 60#;
-	PT _ (TS _ 61) -> cont 61#;
-	PT _ (TI happy_dollar_dollar) -> cont 62#;
-	PT _ (T_PosInteger _) -> cont 63#;
-	PT _ (T_PosDouble _) -> cont 64#;
-	PT _ (T_PosString _) -> cont 65#;
-	PT _ (T_PosIdent _) -> cont 66#;
-	_ -> cont 67#;
-	_ -> happyError' (tk:tks)
-	}
-
-happyError_ 68# tk tks = happyError' tks
-happyError_ _ tk tks = happyError' (tk:tks)
-
-happyThen :: () => Err a -> (a -> Err b) -> Err b
-happyThen = (thenM)
-happyReturn :: () => a -> Err a
-happyReturn = (returnM)
-happyThen1 m k tks = (thenM) m (\a -> k a tks)
-happyReturn1 :: () => a -> b -> Err a
-happyReturn1 = \a tks -> (returnM) a
-happyError' :: () => [(Token)] -> Err a
-happyError' = happyError
-
-pModule tks = happySomeParser where
-  happySomeParser = happyThen (happyParse 0# tks) (\x -> happyReturn (happyOut9 x))
-
-happySeq = happyDontSeq
-
-
-returnM :: a -> Err a
-returnM = return
-
-thenM :: Err a -> (a -> Err b) -> Err b
-thenM = (>>=)
-
-happyError :: [Token] -> Err a
-
-gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
-pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
-pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
-pp _ = error "EOF" -- End of file. What to do here?
-
-happyError ts =
-  Bad (pp ts) $
-  case ts of
-    [] -> []
-    [Err _] -> "due to lexer error"
-    _ -> "before " ++ unwords (map (id . prToken) (take 4 ts))
-
-myLexer = tokens
-{-# LINE 1 "templates/GenericTemplate.hs" #-}
-{-# LINE 1 "templates/GenericTemplate.hs" #-}
-{-# LINE 1 "<built-in>" #-}
-{-# LINE 1 "<command-line>" #-}
-{-# LINE 1 "templates/GenericTemplate.hs" #-}
--- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp 
-
-{-# LINE 30 "templates/GenericTemplate.hs" #-}
-
-
-data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList
-
-
-
-
-
-{-# LINE 51 "templates/GenericTemplate.hs" #-}
-
-{-# LINE 61 "templates/GenericTemplate.hs" #-}
-
-{-# LINE 70 "templates/GenericTemplate.hs" #-}
-
-infixr 9 `HappyStk`
-data HappyStk a = HappyStk a (HappyStk a)
-
------------------------------------------------------------------------------
--- starting the parse
-
-happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll
-
------------------------------------------------------------------------------
--- Accepting the parse
-
--- If the current token is 0#, it means we've just accepted a partial
--- parse (a %partial parser).  We must ignore the saved token on the top of
--- the stack in this case.
-happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =
-	happyReturn1 ans
-happyAccept j tk st sts (HappyStk ans _) = 
-	(happyTcHack j (happyTcHack st)) (happyReturn1 ans)
-
------------------------------------------------------------------------------
--- Arrays only: do the next action
-
-
-
-happyDoAction i tk st
-	= {- nothing -}
-
-
-	  case action of
-		0#		  -> {- nothing -}
-				     happyFail i tk st
-		-1# 	  -> {- nothing -}
-				     happyAccept i tk st
-		n | (n Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}
-
-				     (happyReduceArr Happy_Data_Array.! rule) i tk st
-				     where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
-		n		  -> {- nothing -}
-
-
-				     happyShift new_state i tk st
-				     where (new_state) = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
-   where (off)    = indexShortOffAddr happyActOffsets st
-         (off_i)  = (off Happy_GHC_Exts.+# i)
-	 check  = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#))
-			then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==#  i)
-			else False
-         (action)
-          | check     = indexShortOffAddr happyTable off_i
-          | otherwise = indexShortOffAddr happyDefActions st
-
-{-# LINE 130 "templates/GenericTemplate.hs" #-}
-
-
-indexShortOffAddr (HappyA# arr) off =
-	Happy_GHC_Exts.narrow16Int# i
-  where
-        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
-        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
-        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
-        off' = off Happy_GHC_Exts.*# 2#
-
-
-
-
-
-data HappyAddr = HappyA# Happy_GHC_Exts.Addr#
-
-
-
-
------------------------------------------------------------------------------
--- HappyState data type (not arrays)
-
-{-# LINE 163 "templates/GenericTemplate.hs" #-}
-
------------------------------------------------------------------------------
--- Shifting a token
-
-happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
-     let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
---     trace "shifting the error token" $
-     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)
-
-happyShift new_state i tk st sts stk =
-     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)
-
--- happyReduce is specialised for the common cases.
-
-happySpecReduce_0 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_0 nt fn j tk st@((action)) sts stk
-     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)
-
-happySpecReduce_1 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
-     = let r = fn v1 in
-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
-
-happySpecReduce_2 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
-     = let r = fn v1 v2 in
-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
-
-happySpecReduce_3 i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
-     = let r = fn v1 v2 v3 in
-       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))
-
-happyReduce k i fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happyReduce k nt fn j tk st sts stk
-     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
-	 sts1@((HappyCons (st1@(action)) (_))) ->
-        	let r = fn stk in  -- it doesn't hurt to always seq here...
-       		happyDoSeq r (happyGoto nt j tk st1 sts1 r)
-
-happyMonadReduce k nt fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happyMonadReduce k nt fn j tk st sts stk =
-        happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))
-       where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))
-             drop_stk = happyDropStk k stk
-
-happyMonad2Reduce k nt fn 0# tk st sts stk
-     = happyFail 0# tk st sts stk
-happyMonad2Reduce k nt fn j tk st sts stk =
-       happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))
-       where (sts1@((HappyCons (st1@(action)) (_)))) = happyDrop k (HappyCons (st) (sts))
-             drop_stk = happyDropStk k stk
-
-             (off) = indexShortOffAddr happyGotoOffsets st1
-             (off_i) = (off Happy_GHC_Exts.+# nt)
-             (new_state) = indexShortOffAddr happyTable off_i
-
-
-
-
-happyDrop 0# l = l
-happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t
-
-happyDropStk 0# l = l
-happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs
-
------------------------------------------------------------------------------
--- Moving to a new state after a reduction
-
-
-happyGoto nt j tk st = 
-   {- nothing -}
-   happyDoAction j tk new_state
-   where (off) = indexShortOffAddr happyGotoOffsets st
-         (off_i) = (off Happy_GHC_Exts.+# nt)
-         (new_state) = indexShortOffAddr happyTable off_i
-
-
-
-
------------------------------------------------------------------------------
--- Error recovery (0# is the error token)
-
--- parse error if we are in recovery and we fail again
-happyFail 0# tk old_st _ stk@(x `HappyStk` _) =
-     let (i) = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
---	trace "failing" $ 
-        happyError_ i tk
-
-{-  We don't need state discarding for our restricted implementation of
-    "error".  In fact, it can cause some bogus parses, so I've disabled it
-    for now --SDM
-
--- discard a state
-happyFail  0# tk old_st (HappyCons ((action)) (sts)) 
-						(saved_tok `HappyStk` _ `HappyStk` stk) =
---	trace ("discarding state, depth " ++ show (length stk))  $
-	happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk))
--}
-
--- Enter error recovery: generate an error token,
---                       save the old token and carry on.
-happyFail  i tk (action) sts stk =
---      trace "entering error recovery" $
-	happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)
-
--- Internal happy errors:
-
-notHappyAtAll :: a
-notHappyAtAll = error "Internal Happy error\n"
-
------------------------------------------------------------------------------
--- Hack to get the typechecker to accept our action functions
-
-
-happyTcHack :: Happy_GHC_Exts.Int# -> a -> a
-happyTcHack x y = y
-{-# INLINE happyTcHack #-}
-
-
------------------------------------------------------------------------------
--- Seq-ing.  If the --strict flag is given, then Happy emits 
---	happySeq = happyDoSeq
--- otherwise it emits
--- 	happySeq = happyDontSeq
-
-happyDoSeq, happyDontSeq :: a -> b -> b
-happyDoSeq   a b = a `seq` b
-happyDontSeq a b = b
-
------------------------------------------------------------------------------
--- Don't inline any functions from the template.  GHC has a nasty habit
--- of deciding to inline happyGoto everywhere, which increases the size of
--- the generated parser quite a bit.
-
-
-{-# NOINLINE happyDoAction #-}
-{-# NOINLINE happyTable #-}
-{-# NOINLINE happyCheck #-}
-{-# NOINLINE happyActOffsets #-}
-{-# NOINLINE happyGotoOffsets #-}
-{-# NOINLINE happyDefActions #-}
-
-{-# NOINLINE happyShift #-}
-{-# NOINLINE happySpecReduce_0 #-}
-{-# NOINLINE happySpecReduce_1 #-}
-{-# NOINLINE happySpecReduce_2 #-}
-{-# NOINLINE happySpecReduce_3 #-}
-{-# NOINLINE happyReduce #-}
-{-# NOINLINE happyMonadReduce #-}
-{-# NOINLINE happyGoto #-}
-{-# NOINLINE happyFail #-}
-
--- end of Happy Template.
+ src/Language/Clafer/Front/Parclafer.y view
@@ -0,0 +1,397 @@+-- This Happy file was machine-generated by the BNF converter
+{
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns -fno-warn-overlapping-patterns #-}
+module Language.Clafer.Front.Parclafer where
+import Language.Clafer.Front.Absclafer
+import Language.Clafer.Front.Lexclafer
+import Language.Clafer.Front.ErrM
+
+}
+
+%name pModule Module
+
+-- no lexer declaration
+%monad { Err } { thenM } { returnM }
+%tokentype { Token }
+
+%token 
+ '!' { PT _ (TS _ 1) }
+ '!=' { PT _ (TS _ 2) }
+ '#' { PT _ (TS _ 3) }
+ '&' { PT _ (TS _ 4) }
+ '&&' { PT _ (TS _ 5) }
+ '(' { PT _ (TS _ 6) }
+ ')' { PT _ (TS _ 7) }
+ '*' { PT _ (TS _ 8) }
+ '+' { PT _ (TS _ 9) }
+ '++' { PT _ (TS _ 10) }
+ ',' { PT _ (TS _ 11) }
+ '-' { PT _ (TS _ 12) }
+ '--' { PT _ (TS _ 13) }
+ '->' { PT _ (TS _ 14) }
+ '->>' { PT _ (TS _ 15) }
+ '.' { PT _ (TS _ 16) }
+ '..' { PT _ (TS _ 17) }
+ '/' { PT _ (TS _ 18) }
+ ':' { PT _ (TS _ 19) }
+ ':=' { PT _ (TS _ 20) }
+ ':>' { PT _ (TS _ 21) }
+ ';' { PT _ (TS _ 22) }
+ '<' { PT _ (TS _ 23) }
+ '<:' { PT _ (TS _ 24) }
+ '<<' { PT _ (TS _ 25) }
+ '<=' { PT _ (TS _ 26) }
+ '<=>' { PT _ (TS _ 27) }
+ '=' { PT _ (TS _ 28) }
+ '=>' { PT _ (TS _ 29) }
+ '>' { PT _ (TS _ 30) }
+ '>=' { PT _ (TS _ 31) }
+ '>>' { PT _ (TS _ 32) }
+ '?' { PT _ (TS _ 33) }
+ '[' { PT _ (TS _ 34) }
+ '\\' { PT _ (TS _ 35) }
+ ']' { PT _ (TS _ 36) }
+ '`' { PT _ (TS _ 37) }
+ 'abstract' { PT _ (TS _ 38) }
+ 'all' { PT _ (TS _ 39) }
+ 'disj' { PT _ (TS _ 40) }
+ 'else' { PT _ (TS _ 41) }
+ 'enum' { PT _ (TS _ 42) }
+ 'if' { PT _ (TS _ 43) }
+ 'in' { PT _ (TS _ 44) }
+ 'lone' { PT _ (TS _ 45) }
+ 'max' { PT _ (TS _ 46) }
+ 'min' { PT _ (TS _ 47) }
+ 'mux' { PT _ (TS _ 48) }
+ 'no' { PT _ (TS _ 49) }
+ 'not' { PT _ (TS _ 50) }
+ 'one' { PT _ (TS _ 51) }
+ 'opt' { PT _ (TS _ 52) }
+ 'or' { PT _ (TS _ 53) }
+ 'some' { PT _ (TS _ 54) }
+ 'sum' { PT _ (TS _ 55) }
+ 'then' { PT _ (TS _ 56) }
+ 'xor' { PT _ (TS _ 57) }
+ '{' { PT _ (TS _ 58) }
+ '|' { PT _ (TS _ 59) }
+ '||' { PT _ (TS _ 60) }
+ '}' { PT _ (TS _ 61) }
+
+L_PosInteger { PT _ (T_PosInteger _) }
+L_PosDouble { PT _ (T_PosDouble _) }
+L_PosString { PT _ (T_PosString _) }
+L_PosIdent { PT _ (T_PosIdent _) }
+L_err    { _ }
+
+
+%%
+
+PosInteger    :: { PosInteger} : L_PosInteger { PosInteger (mkPosToken $1)}
+PosDouble    :: { PosDouble} : L_PosDouble { PosDouble (mkPosToken $1)}
+PosString    :: { PosString} : L_PosString { PosString (mkPosToken $1)}
+PosIdent    :: { PosIdent} : L_PosIdent { PosIdent (mkPosToken $1)}
+
+Module :: { Module }
+Module : ListDeclaration { Module ((mkCatSpan $1)) (reverse $1) } 
+
+
+Declaration :: { Declaration }
+Declaration : 'enum' PosIdent '=' ListEnumId { EnumDecl ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 } 
+  | Element { ElementDecl ((mkCatSpan $1)) $1 }
+
+
+Clafer :: { Clafer }
+Clafer : Abstract GCard PosIdent Super Card Init Elements { Clafer ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3) >- (mkCatSpan $4) >- (mkCatSpan $5) >- (mkCatSpan $6) >- (mkCatSpan $7)) $1 $2 $3 $4 $5 $6 $7 } 
+
+
+Constraint :: { Constraint }
+Constraint : '[' ListExp ']' { Constraint ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) } 
+
+
+SoftConstraint :: { SoftConstraint }
+SoftConstraint : '(' ListExp ')' { SoftConstraint ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) } 
+
+
+Goal :: { Goal }
+Goal : '<<' ListExp '>>' { Goal ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) } 
+
+
+Abstract :: { Abstract }
+Abstract : {- empty -} { AbstractEmpty noSpan } 
+  | 'abstract' { Abstract ((mkTokenSpan $1)) }
+
+
+Elements :: { Elements }
+Elements : {- empty -} { ElementsEmpty noSpan } 
+  | '{' ListElement '}' { ElementsList ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3)) (reverse $2) }
+
+
+Element :: { Element }
+Element : Clafer { Subclafer ((mkCatSpan $1)) $1 } 
+  | '`' Name Card Elements { ClaferUse ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkCatSpan $3) >- (mkCatSpan $4)) $2 $3 $4 }
+  | Constraint { Subconstraint ((mkCatSpan $1)) $1 }
+  | Goal { Subgoal ((mkCatSpan $1)) $1 }
+  | SoftConstraint { Subsoftconstraint ((mkCatSpan $1)) $1 }
+
+
+Super :: { Super }
+Super : {- empty -} { SuperEmpty noSpan } 
+  | SuperHow SetExp { SuperSome ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
+
+
+SuperHow :: { SuperHow }
+SuperHow : ':' { SuperColon ((mkTokenSpan $1)) } 
+  | '->' { SuperArrow ((mkTokenSpan $1)) }
+  | '->>' { SuperMArrow ((mkTokenSpan $1)) }
+
+
+Init :: { Init }
+Init : {- empty -} { InitEmpty noSpan } 
+  | InitHow Exp { InitSome ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 }
+
+
+InitHow :: { InitHow }
+InitHow : '=' { InitHow_1 ((mkTokenSpan $1)) } 
+  | ':=' { InitHow_2 ((mkTokenSpan $1)) }
+
+
+GCard :: { GCard }
+GCard : {- empty -} { GCardEmpty noSpan } 
+  | 'xor' { GCardXor ((mkTokenSpan $1)) }
+  | 'or' { GCardOr ((mkTokenSpan $1)) }
+  | 'mux' { GCardMux ((mkTokenSpan $1)) }
+  | 'opt' { GCardOpt ((mkTokenSpan $1)) }
+  | NCard { GCardInterval ((mkCatSpan $1)) $1 }
+
+
+Card :: { Card }
+Card : {- empty -} { CardEmpty noSpan } 
+  | '?' { CardLone ((mkTokenSpan $1)) }
+  | '+' { CardSome ((mkTokenSpan $1)) }
+  | '*' { CardAny ((mkTokenSpan $1)) }
+  | PosInteger { CardNum ((mkCatSpan $1)) $1 }
+  | NCard { CardInterval ((mkCatSpan $1)) $1 }
+
+
+NCard :: { NCard }
+NCard : PosInteger '..' ExInteger { NCard ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+
+
+ExInteger :: { ExInteger }
+ExInteger : '*' { ExIntegerAst ((mkTokenSpan $1)) } 
+  | PosInteger { ExIntegerNum ((mkCatSpan $1)) $1 }
+
+
+Name :: { Name }
+Name : ListModId { Path ((mkCatSpan $1)) $1 } 
+
+
+Exp :: { Exp }
+Exp : 'all' 'disj' Decl '|' Exp { DeclAllDisj ((mkTokenSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4) >- (mkCatSpan $5)) $3 $5 } 
+  | 'all' Decl '|' Exp { DeclAll ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $2 $4 }
+  | Quant 'disj' Decl '|' Exp { DeclQuantDisj ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3) >- (mkTokenSpan $4) >- (mkCatSpan $5)) $1 $3 $5 }
+  | Quant Decl '|' Exp { DeclQuant ((mkCatSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $1 $2 $4 }
+  | Exp1 {  $1 }
+
+
+Exp1 :: { Exp }
+Exp1 : 'max' Exp2 { EGMax ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 } 
+  | 'min' Exp2 { EGMin ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+  | Exp1 '<=>' Exp2 { EIff ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp2 {  $1 }
+
+
+Exp2 :: { Exp }
+Exp2 : Exp2 '=>' Exp3 { EImplies ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp3 {  $1 }
+
+
+Exp3 :: { Exp }
+Exp3 : Exp3 '||' Exp4 { EOr ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp4 {  $1 }
+
+
+Exp4 :: { Exp }
+Exp4 : Exp4 'xor' Exp5 { EXor ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp5 {  $1 }
+
+
+Exp5 :: { Exp }
+Exp5 : Exp5 '&&' Exp6 { EAnd ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp6 {  $1 }
+
+
+Exp6 :: { Exp }
+Exp6 : '!' Exp7 { ENeg ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 } 
+  | Exp7 {  $1 }
+
+
+Exp7 :: { Exp }
+Exp7 : Exp7 '<' Exp8 { ELt ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp7 '>' Exp8 { EGt ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp7 '=' Exp8 { EEq ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp7 '<=' Exp8 { ELte ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp7 '>=' Exp8 { EGte ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp7 '!=' Exp8 { ENeq ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp7 'in' Exp8 { EIn ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp7 'not' 'in' Exp8 { ENin ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4)) $1 $4 }
+  | Exp8 {  $1 }
+
+
+Exp8 :: { Exp }
+Exp8 : Quant Exp12 { QuantExp ((mkCatSpan $1) >- (mkCatSpan $2)) $1 $2 } 
+  | Exp9 {  $1 }
+
+
+Exp9 :: { Exp }
+Exp9 : Exp9 '+' Exp10 { EAdd ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp9 '-' Exp10 { ESub ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp10 {  $1 }
+
+
+Exp10 :: { Exp }
+Exp10 : Exp10 '*' Exp11 { EMul ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | Exp10 '/' Exp11 { EDiv ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | Exp11 {  $1 }
+
+
+Exp11 :: { Exp }
+Exp11 : 'sum' Exp12 { ESumSetExp ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 } 
+  | '#' Exp12 { ECSetExp ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+  | '-' Exp12 { EMinExp ((mkTokenSpan $1) >- (mkCatSpan $2)) $2 }
+  | Exp12 {  $1 }
+
+
+Exp12 :: { Exp }
+Exp12 : 'if' Exp12 'then' Exp12 'else' Exp13 { EImpliesElse ((mkTokenSpan $1) >- (mkCatSpan $2) >- (mkTokenSpan $3) >- (mkCatSpan $4) >- (mkTokenSpan $5) >- (mkCatSpan $6)) $2 $4 $6 } 
+  | Exp13 {  $1 }
+
+
+Exp13 :: { Exp }
+Exp13 : PosInteger { EInt ((mkCatSpan $1)) $1 } 
+  | PosDouble { EDouble ((mkCatSpan $1)) $1 }
+  | PosString { EStr ((mkCatSpan $1)) $1 }
+  | SetExp { ESetExp ((mkCatSpan $1)) $1 }
+  | '(' Exp ')' {  $2 }
+
+
+SetExp :: { SetExp }
+SetExp : SetExp '++' SetExp1 { Union ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | SetExp ',' SetExp1 { UnionCom ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 }
+  | SetExp1 {  $1 }
+
+
+SetExp1 :: { SetExp }
+SetExp1 : SetExp1 '--' SetExp2 { Difference ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | SetExp2 {  $1 }
+
+
+SetExp2 :: { SetExp }
+SetExp2 : SetExp2 '&' SetExp3 { Intersection ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | SetExp3 {  $1 }
+
+
+SetExp3 :: { SetExp }
+SetExp3 : SetExp3 '<:' SetExp4 { Domain ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | SetExp4 {  $1 }
+
+
+SetExp4 :: { SetExp }
+SetExp4 : SetExp4 ':>' SetExp5 { Range ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | SetExp5 {  $1 }
+
+
+SetExp5 :: { SetExp }
+SetExp5 : SetExp5 '.' SetExp6 { Join ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+  | SetExp6 {  $1 }
+
+
+SetExp6 :: { SetExp }
+SetExp6 : Name { ClaferId ((mkCatSpan $1)) $1 } 
+  | '(' SetExp ')' {  $2 }
+
+
+Decl :: { Decl }
+Decl : ListLocId ':' SetExp { Decl ((mkCatSpan $1) >- (mkTokenSpan $2) >- (mkCatSpan $3)) $1 $3 } 
+
+
+Quant :: { Quant }
+Quant : 'no' { QuantNo ((mkTokenSpan $1)) } 
+  | 'not' { QuantNot ((mkTokenSpan $1)) }
+  | 'lone' { QuantLone ((mkTokenSpan $1)) }
+  | 'one' { QuantOne ((mkTokenSpan $1)) }
+  | 'some' { QuantSome ((mkTokenSpan $1)) }
+
+
+EnumId :: { EnumId }
+EnumId : PosIdent { EnumIdIdent ((mkCatSpan $1)) $1 } 
+
+
+ModId :: { ModId }
+ModId : PosIdent { ModIdIdent ((mkCatSpan $1)) $1 } 
+
+
+LocId :: { LocId }
+LocId : PosIdent { LocIdIdent ((mkCatSpan $1)) $1 } 
+
+
+ListDeclaration :: { [Declaration] }
+ListDeclaration : {- empty -} { []  } 
+  | ListDeclaration Declaration { flip (:)  $1 $2 }
+
+
+ListEnumId :: { [EnumId] }
+ListEnumId : EnumId { (:[])  $1 } 
+  | EnumId '|' ListEnumId { (:)  $1 $3 }
+
+
+ListElement :: { [Element] }
+ListElement : {- empty -} { []  } 
+  | ListElement Element { flip (:)  $1 $2 }
+
+
+ListExp :: { [Exp] }
+ListExp : {- empty -} { []  } 
+  | ListExp Exp { flip (:)  $1 $2 }
+
+
+ListLocId :: { [LocId] }
+ListLocId : LocId { (:[])  $1 } 
+  | LocId ';' ListLocId { (:)  $1 $3 }
+
+
+ListModId :: { [ModId] }
+ListModId : ModId { (:[])  $1 } 
+  | ModId '\\' ListModId { (:)  $1 $3 }
+
+
+
+{
+
+returnM :: a -> Err a
+returnM = return
+
+thenM :: Err a -> (a -> Err b) -> Err b
+thenM = (>>=)
+
+happyError :: [Token] -> Err a
+happyError ts =
+  Bad (pp ts) $
+  case ts of
+    [] -> []
+    [Err _] -> " due to lexer error"
+    _ -> "before " ++ unwords (map (id . prToken) (take 4 ts))
+
+gp x@(PT (Pn _ l c) _) = Span (Pos (toInteger l) (toInteger c)) (Pos (toInteger l) (toInteger c + toInteger (length $ prToken x)))
+pp (PT (Pn _ l c) _ :_) = Pos (toInteger l) (toInteger c)
+pp (Err (Pn _ l c) :_) = Pos (toInteger l) (toInteger c)
+pp _ = error "EOF"
+
+mkCatSpan :: (Spannable c) => c -> Span
+mkCatSpan = getSpan
+
+mkTokenSpan :: Token -> Span
+mkTokenSpan = gp
+myLexer = tokens
+}
+
src/Language/Clafer/Front/Printclafer.hs view
@@ -1,10 +1,10 @@-{-# OPTIONS -fno-warn-incomplete-patterns #-}
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
 module Language.Clafer.Front.Printclafer where
 
 -- pretty-printer generated by the BNF converter
 
+import Prelude hiding (exp, init)
 import Language.Clafer.Front.Absclafer
-import Prelude hiding (span, exp, init)
 import Data.Char
 
 
@@ -99,16 +99,13 @@ 
 instance Print Module where
   prt i e = case e of
-   Module declarations -> prPrec i 0 (concatD [prt 0 declarations])
-   PosModule span declarations -> prPrec i 0 (concatD [prt 0 span , prt 0 declarations])
+   Module _ declarations -> prPrec i 0 (concatD [prt 0 declarations])
 
 
 instance Print Declaration where
   prt i e = case e of
-   EnumDecl posident enumids -> prPrec i 0 (concatD [doc (showString "enum") , prt 0 posident , doc (showString "=") , prt 0 enumids])
-   PosEnumDecl span posident enumids -> prPrec i 0 (concatD [prt 0 span , doc (showString "enum") , prt 0 posident , doc (showString "=") , prt 0 enumids])
-   ElementDecl element -> prPrec i 0 (concatD [prt 0 element])
-   PosElementDecl span element -> prPrec i 0 (concatD [prt 0 span , prt 0 element])
+   EnumDecl _ posident enumids -> prPrec i 0 (concatD [doc (showString "enum") , prt 0 posident , doc (showString "=") , prt 0 enumids])
+   ElementDecl _ element -> prPrec i 0 (concatD [prt 0 element])
 
   prtList es = case es of
    [] -> (concatD [])
@@ -116,56 +113,43 @@ 
 instance Print Clafer where
   prt i e = case e of
-   Clafer abstract gcard posident super card init elements -> prPrec i 0 (concatD [prt 0 abstract , prt 0 gcard , prt 0 posident , prt 0 super , prt 0 card , prt 0 init , prt 0 elements])
-   PosClafer span abstract gcard posident super card init elements -> prPrec i 0 (concatD [prt 0 span , prt 0 abstract , prt 0 gcard , prt 0 posident , prt 0 super , prt 0 card , prt 0 init , prt 0 elements])
+   Clafer _ abstract gcard posident super card init elements -> prPrec i 0 (concatD [prt 0 abstract , prt 0 gcard , prt 0 posident , prt 0 super , prt 0 card , prt 0 init , prt 0 elements])
 
 
 instance Print Constraint where
   prt i e = case e of
-   Constraint exps -> prPrec i 0 (concatD [doc (showString "[") , prt 0 exps , doc (showString "]")])
-   PosConstraint span exps -> prPrec i 0 (concatD [prt 0 span , doc (showString "[") , prt 0 exps , doc (showString "]")])
+   Constraint _ exps -> prPrec i 0 (concatD [doc (showString "[") , prt 0 exps , doc (showString "]")])
 
 
 instance Print SoftConstraint where
   prt i e = case e of
-   SoftConstraint exps -> prPrec i 0 (concatD [doc (showString "(") , prt 0 exps , doc (showString ")")])
-   PosSoftConstraint span exps -> prPrec i 0 (concatD [prt 0 span , doc (showString "(") , prt 0 exps , doc (showString ")")])
+   SoftConstraint _ exps -> prPrec i 0 (concatD [doc (showString "(") , prt 0 exps , doc (showString ")")])
 
 
 instance Print Goal where
   prt i e = case e of
-   Goal exps -> prPrec i 0 (concatD [doc (showString "<<") , prt 0 exps , doc (showString ">>")])
-   PosGoal span exps -> prPrec i 0 (concatD [prt 0 span , doc (showString "<<") , prt 0 exps , doc (showString ">>")])
+   Goal _ exps -> prPrec i 0 (concatD [doc (showString "<<") , prt 0 exps , doc (showString ">>")])
 
 
 instance Print Abstract where
   prt i e = case e of
-   AbstractEmpty  -> prPrec i 0 (concatD [])
-   PosAbstractEmpty span -> prPrec i 0 (concatD [prt 0 span])
-   Abstract  -> prPrec i 0 (concatD [doc (showString "abstract")])
-   PosAbstract span -> prPrec i 0 (concatD [prt 0 span , doc (showString "abstract")])
+   AbstractEmpty _  -> prPrec i 0 (concatD [])
+   Abstract _  -> prPrec i 0 (concatD [doc (showString "abstract")])
 
 
 instance Print Elements where
   prt i e = case e of
-   ElementsEmpty  -> prPrec i 0 (concatD [])
-   PosElementsEmpty span -> prPrec i 0 (concatD [prt 0 span])
-   ElementsList elements -> prPrec i 0 (concatD [doc (showString "{") , prt 0 elements , doc (showString "}")])
-   PosElementsList span elements -> prPrec i 0 (concatD [prt 0 span , doc (showString "{") , prt 0 elements , doc (showString "}")])
+   ElementsEmpty _  -> prPrec i 0 (concatD [])
+   ElementsList _ elements -> prPrec i 0 (concatD [doc (showString "{") , prt 0 elements , doc (showString "}")])
 
 
 instance Print Element where
   prt i e = case e of
-   Subclafer clafer -> prPrec i 0 (concatD [prt 0 clafer])
-   PosSubclafer span clafer -> prPrec i 0 (concatD [prt 0 span , prt 0 clafer])
-   ClaferUse name card elements -> prPrec i 0 (concatD [doc (showString "`") , prt 0 name , prt 0 card , prt 0 elements])
-   PosClaferUse span name card elements -> prPrec i 0 (concatD [prt 0 span , doc (showString "`") , prt 0 name , prt 0 card , prt 0 elements])
-   Subconstraint constraint -> prPrec i 0 (concatD [prt 0 constraint])
-   PosSubconstraint span constraint -> prPrec i 0 (concatD [prt 0 span , prt 0 constraint])
-   Subgoal goal -> prPrec i 0 (concatD [prt 0 goal])
-   PosSubgoal span goal -> prPrec i 0 (concatD [prt 0 span , prt 0 goal])
-   Subsoftconstraint softconstraint -> prPrec i 0 (concatD [prt 0 softconstraint])
-   PosSubsoftconstraint span softconstraint -> prPrec i 0 (concatD [prt 0 span , prt 0 softconstraint])
+   Subclafer _ clafer -> prPrec i 0 (concatD [prt 0 clafer])
+   ClaferUse _ name card elements -> prPrec i 0 (concatD [doc (showString "`") , prt 0 name , prt 0 card , prt 0 elements])
+   Subconstraint _ constraint -> prPrec i 0 (concatD [prt 0 constraint])
+   Subgoal _ goal -> prPrec i 0 (concatD [prt 0 goal])
+   Subsoftconstraint _ softconstraint -> prPrec i 0 (concatD [prt 0 softconstraint])
 
   prtList es = case es of
    [] -> (concatD [])
@@ -173,158 +157,100 @@ 
 instance Print Super where
   prt i e = case e of
-   SuperEmpty  -> prPrec i 0 (concatD [])
-   PosSuperEmpty span -> prPrec i 0 (concatD [prt 0 span])
-   SuperSome superhow setexp -> prPrec i 0 (concatD [prt 0 superhow , prt 0 setexp])
-   PosSuperSome span superhow setexp -> prPrec i 0 (concatD [prt 0 span , prt 0 superhow , prt 0 setexp])
+   SuperEmpty _  -> prPrec i 0 (concatD [])
+   SuperSome _ superhow setexp -> prPrec i 0 (concatD [prt 0 superhow , prt 0 setexp])
 
 
 instance Print SuperHow where
   prt i e = case e of
-   SuperColon  -> prPrec i 0 (concatD [doc (showString ":")])
-   PosSuperColon span -> prPrec i 0 (concatD [prt 0 span , doc (showString ":")])
-   SuperArrow  -> prPrec i 0 (concatD [doc (showString "->")])
-   PosSuperArrow span -> prPrec i 0 (concatD [prt 0 span , doc (showString "->")])
-   SuperMArrow  -> prPrec i 0 (concatD [doc (showString "->>")])
-   PosSuperMArrow span -> prPrec i 0 (concatD [prt 0 span , doc (showString "->>")])
+   SuperColon _  -> prPrec i 0 (concatD [doc (showString ":")])
+   SuperArrow _  -> prPrec i 0 (concatD [doc (showString "->")])
+   SuperMArrow _  -> prPrec i 0 (concatD [doc (showString "->>")])
 
 
 instance Print Init where
   prt i e = case e of
-   InitEmpty  -> prPrec i 0 (concatD [])
-   PosInitEmpty span -> prPrec i 0 (concatD [prt 0 span])
-   InitSome inithow exp -> prPrec i 0 (concatD [prt 0 inithow , prt 0 exp])
-   PosInitSome span inithow exp -> prPrec i 0 (concatD [prt 0 span , prt 0 inithow , prt 0 exp])
+   InitEmpty _  -> prPrec i 0 (concatD [])
+   InitSome _ inithow exp -> prPrec i 0 (concatD [prt 0 inithow , prt 0 exp])
 
 
 instance Print InitHow where
   prt i e = case e of
-   InitHow_1  -> prPrec i 0 (concatD [doc (showString "=")])
-   PosInitHow_1 span -> prPrec i 0 (concatD [prt 0 span , doc (showString "=")])
-   InitHow_2  -> prPrec i 0 (concatD [doc (showString ":=")])
-   PosInitHow_2 span -> prPrec i 0 (concatD [prt 0 span , doc (showString ":=")])
+   InitHow_1 _  -> prPrec i 0 (concatD [doc (showString "=")])
+   InitHow_2 _  -> prPrec i 0 (concatD [doc (showString ":=")])
 
 
 instance Print GCard where
   prt i e = case e of
-   GCardEmpty  -> prPrec i 0 (concatD [])
-   PosGCardEmpty span -> prPrec i 0 (concatD [prt 0 span])
-   GCardXor  -> prPrec i 0 (concatD [doc (showString "xor")])
-   PosGCardXor span -> prPrec i 0 (concatD [prt 0 span , doc (showString "xor")])
-   GCardOr  -> prPrec i 0 (concatD [doc (showString "or")])
-   PosGCardOr span -> prPrec i 0 (concatD [prt 0 span , doc (showString "or")])
-   GCardMux  -> prPrec i 0 (concatD [doc (showString "mux")])
-   PosGCardMux span -> prPrec i 0 (concatD [prt 0 span , doc (showString "mux")])
-   GCardOpt  -> prPrec i 0 (concatD [doc (showString "opt")])
-   PosGCardOpt span -> prPrec i 0 (concatD [prt 0 span , doc (showString "opt")])
-   GCardInterval ncard -> prPrec i 0 (concatD [prt 0 ncard])
-   PosGCardInterval span ncard -> prPrec i 0 (concatD [prt 0 span , prt 0 ncard])
+   GCardEmpty _  -> prPrec i 0 (concatD [])
+   GCardXor _  -> prPrec i 0 (concatD [doc (showString "xor")])
+   GCardOr _  -> prPrec i 0 (concatD [doc (showString "or")])
+   GCardMux _  -> prPrec i 0 (concatD [doc (showString "mux")])
+   GCardOpt _  -> prPrec i 0 (concatD [doc (showString "opt")])
+   GCardInterval _ ncard -> prPrec i 0 (concatD [prt 0 ncard])
 
 
 instance Print Card where
   prt i e = case e of
-   CardEmpty  -> prPrec i 0 (concatD [])
-   PosCardEmpty span -> prPrec i 0 (concatD [prt 0 span])
-   CardLone  -> prPrec i 0 (concatD [doc (showString "?")])
-   PosCardLone span -> prPrec i 0 (concatD [prt 0 span , doc (showString "?")])
-   CardSome  -> prPrec i 0 (concatD [doc (showString "+")])
-   PosCardSome span -> prPrec i 0 (concatD [prt 0 span , doc (showString "+")])
-   CardAny  -> prPrec i 0 (concatD [doc (showString "*")])
-   PosCardAny span -> prPrec i 0 (concatD [prt 0 span , doc (showString "*")])
-   CardNum posinteger -> prPrec i 0 (concatD [prt 0 posinteger])
-   PosCardNum span posinteger -> prPrec i 0 (concatD [prt 0 span , prt 0 posinteger])
-   CardInterval ncard -> prPrec i 0 (concatD [prt 0 ncard])
-   PosCardInterval span ncard -> prPrec i 0 (concatD [prt 0 span , prt 0 ncard])
+   CardEmpty _  -> prPrec i 0 (concatD [])
+   CardLone _  -> prPrec i 0 (concatD [doc (showString "?")])
+   CardSome _  -> prPrec i 0 (concatD [doc (showString "+")])
+   CardAny _  -> prPrec i 0 (concatD [doc (showString "*")])
+   CardNum _ posinteger -> prPrec i 0 (concatD [prt 0 posinteger])
+   CardInterval _ ncard -> prPrec i 0 (concatD [prt 0 ncard])
 
 
 instance Print NCard where
   prt i e = case e of
-   NCard posinteger exinteger -> prPrec i 0 (concatD [prt 0 posinteger , doc (showString "..") , prt 0 exinteger])
-   PosNCard span posinteger exinteger -> prPrec i 0 (concatD [prt 0 span , prt 0 posinteger , doc (showString "..") , prt 0 exinteger])
+   NCard _ posinteger exinteger -> prPrec i 0 (concatD [prt 0 posinteger , doc (showString "..") , prt 0 exinteger])
 
 
 instance Print ExInteger where
   prt i e = case e of
-   ExIntegerAst  -> prPrec i 0 (concatD [doc (showString "*")])
-   PosExIntegerAst span -> prPrec i 0 (concatD [prt 0 span , doc (showString "*")])
-   ExIntegerNum posinteger -> prPrec i 0 (concatD [prt 0 posinteger])
-   PosExIntegerNum span posinteger -> prPrec i 0 (concatD [prt 0 span , prt 0 posinteger])
+   ExIntegerAst _  -> prPrec i 0 (concatD [doc (showString "*")])
+   ExIntegerNum _ posinteger -> prPrec i 0 (concatD [prt 0 posinteger])
 
 
 instance Print Name where
   prt i e = case e of
-   Path modids -> prPrec i 0 (concatD [prt 0 modids])
-   PosPath span modids -> prPrec i 0 (concatD [prt 0 span , prt 0 modids])
+   Path _ modids -> prPrec i 0 (concatD [prt 0 modids])
 
 
 instance Print Exp where
   prt i e = case e of
-   DeclAllDisj decl exp -> prPrec i 0 (concatD [doc (showString "all") , doc (showString "disj") , prt 0 decl , doc (showString "|") , prt 0 exp])
-   PosDeclAllDisj span decl exp -> prPrec i 0 (concatD [prt 0 span , doc (showString "all") , doc (showString "disj") , prt 0 decl , doc (showString "|") , prt 0 exp])
-   DeclAll decl exp -> prPrec i 0 (concatD [doc (showString "all") , prt 0 decl , doc (showString "|") , prt 0 exp])
-   PosDeclAll span decl exp -> prPrec i 0 (concatD [prt 0 span , doc (showString "all") , prt 0 decl , doc (showString "|") , prt 0 exp])
-   DeclQuantDisj quant decl exp -> prPrec i 0 (concatD [prt 0 quant , doc (showString "disj") , prt 0 decl , doc (showString "|") , prt 0 exp])
-   PosDeclQuantDisj span quant decl exp -> prPrec i 0 (concatD [prt 0 span , prt 0 quant , doc (showString "disj") , prt 0 decl , doc (showString "|") , prt 0 exp])
-   DeclQuant quant decl exp -> prPrec i 0 (concatD [prt 0 quant , prt 0 decl , doc (showString "|") , prt 0 exp])
-   PosDeclQuant span quant decl exp -> prPrec i 0 (concatD [prt 0 span , prt 0 quant , prt 0 decl , doc (showString "|") , prt 0 exp])
-   EGMax exp -> prPrec i 1 (concatD [doc (showString "max") , prt 2 exp])
-   PosEGMax span exp -> prPrec i 1 (concatD [prt 0 span , doc (showString "max") , prt 2 exp])
-   EGMin exp -> prPrec i 1 (concatD [doc (showString "min") , prt 2 exp])
-   PosEGMin span exp -> prPrec i 1 (concatD [prt 0 span , doc (showString "min") , prt 2 exp])
-   EIff exp0 exp -> prPrec i 1 (concatD [prt 1 exp0 , doc (showString "<=>") , prt 2 exp])
-   PosEIff span exp0 exp -> prPrec i 1 (concatD [prt 0 span , prt 1 exp0 , doc (showString "<=>") , prt 2 exp])
-   EImplies exp0 exp -> prPrec i 2 (concatD [prt 2 exp0 , doc (showString "=>") , prt 3 exp])
-   PosEImplies span exp0 exp -> prPrec i 2 (concatD [prt 0 span , prt 2 exp0 , doc (showString "=>") , prt 3 exp])
-   EOr exp0 exp -> prPrec i 3 (concatD [prt 3 exp0 , doc (showString "||") , prt 4 exp])
-   PosEOr span exp0 exp -> prPrec i 3 (concatD [prt 0 span , prt 3 exp0 , doc (showString "||") , prt 4 exp])
-   EXor exp0 exp -> prPrec i 4 (concatD [prt 4 exp0 , doc (showString "xor") , prt 5 exp])
-   PosEXor span exp0 exp -> prPrec i 4 (concatD [prt 0 span , prt 4 exp0 , doc (showString "xor") , prt 5 exp])
-   EAnd exp0 exp -> prPrec i 5 (concatD [prt 5 exp0 , doc (showString "&&") , prt 6 exp])
-   PosEAnd span exp0 exp -> prPrec i 5 (concatD [prt 0 span , prt 5 exp0 , doc (showString "&&") , prt 6 exp])
-   ENeg exp -> prPrec i 6 (concatD [doc (showString "!") , prt 7 exp])
-   PosENeg span exp -> prPrec i 6 (concatD [prt 0 span , doc (showString "!") , prt 7 exp])
-   ELt exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "<") , prt 8 exp])
-   PosELt span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString "<") , prt 8 exp])
-   EGt exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString ">") , prt 8 exp])
-   PosEGt span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString ">") , prt 8 exp])
-   EEq exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "=") , prt 8 exp])
-   PosEEq span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString "=") , prt 8 exp])
-   ELte exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "<=") , prt 8 exp])
-   PosELte span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString "<=") , prt 8 exp])
-   EGte exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString ">=") , prt 8 exp])
-   PosEGte span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString ">=") , prt 8 exp])
-   ENeq exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "!=") , prt 8 exp])
-   PosENeq span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString "!=") , prt 8 exp])
-   EIn exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "in") , prt 8 exp])
-   PosEIn span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString "in") , prt 8 exp])
-   ENin exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "not") , doc (showString "in") , prt 8 exp])
-   PosENin span exp0 exp -> prPrec i 7 (concatD [prt 0 span , prt 7 exp0 , doc (showString "not") , doc (showString "in") , prt 8 exp])
-   QuantExp quant exp -> prPrec i 8 (concatD [prt 0 quant , prt 12 exp])
-   PosQuantExp span quant exp -> prPrec i 8 (concatD [prt 0 span , prt 0 quant , prt 12 exp])
-   EAdd exp0 exp -> prPrec i 9 (concatD [prt 9 exp0 , doc (showString "+") , prt 10 exp])
-   PosEAdd span exp0 exp -> prPrec i 9 (concatD [prt 0 span , prt 9 exp0 , doc (showString "+") , prt 10 exp])
-   ESub exp0 exp -> prPrec i 9 (concatD [prt 9 exp0 , doc (showString "-") , prt 10 exp])
-   PosESub span exp0 exp -> prPrec i 9 (concatD [prt 0 span , prt 9 exp0 , doc (showString "-") , prt 10 exp])
-   EMul exp0 exp -> prPrec i 10 (concatD [prt 10 exp0 , doc (showString "*") , prt 11 exp])
-   PosEMul span exp0 exp -> prPrec i 10 (concatD [prt 0 span , prt 10 exp0 , doc (showString "*") , prt 11 exp])
-   EDiv exp0 exp -> prPrec i 10 (concatD [prt 10 exp0 , doc (showString "/") , prt 11 exp])
-   PosEDiv span exp0 exp -> prPrec i 10 (concatD [prt 0 span , prt 10 exp0 , doc (showString "/") , prt 11 exp])
-   ESumSetExp exp -> prPrec i 11 (concatD [doc (showString "sum") , prt 12 exp])
-   PosESumSetExp span exp -> prPrec i 11 (concatD [prt 0 span , doc (showString "sum") , prt 12 exp])
-   ECSetExp exp -> prPrec i 11 (concatD [doc (showString "#") , prt 12 exp])
-   PosECSetExp span exp -> prPrec i 11 (concatD [prt 0 span , doc (showString "#") , prt 12 exp])
-   EMinExp exp -> prPrec i 11 (concatD [doc (showString "-") , prt 12 exp])
-   PosEMinExp span exp -> prPrec i 11 (concatD [prt 0 span , doc (showString "-") , prt 12 exp])
-   EImpliesElse exp0 exp1 exp -> prPrec i 12 (concatD [doc (showString "if") , prt 12 exp0 , doc (showString "then") , prt 12 exp1 , doc (showString "else") , prt 13 exp])
-   PosEImpliesElse span exp0 exp1 exp -> prPrec i 12 (concatD [prt 0 span , doc (showString "if") , prt 12 exp0 , doc (showString "then") , prt 12 exp1 , doc (showString "else") , prt 13 exp])
-   EInt posinteger -> prPrec i 13 (concatD [prt 0 posinteger])
-   PosEInt span posinteger -> prPrec i 13 (concatD [prt 0 span , prt 0 posinteger])
-   EDouble posdouble -> prPrec i 13 (concatD [prt 0 posdouble])
-   PosEDouble span posdouble -> prPrec i 13 (concatD [prt 0 span , prt 0 posdouble])
-   EStr posstring -> prPrec i 13 (concatD [prt 0 posstring])
-   PosEStr span posstring -> prPrec i 13 (concatD [prt 0 span , prt 0 posstring])
-   ESetExp setexp -> prPrec i 13 (concatD [prt 0 setexp])
-   PosESetExp span setexp -> prPrec i 13 (concatD [prt 0 span , prt 0 setexp])
+   DeclAllDisj _ decl exp -> prPrec i 0 (concatD [doc (showString "all") , doc (showString "disj") , prt 0 decl , doc (showString "|") , prt 0 exp])
+   DeclAll _ decl exp -> prPrec i 0 (concatD [doc (showString "all") , prt 0 decl , doc (showString "|") , prt 0 exp])
+   DeclQuantDisj _ quant decl exp -> prPrec i 0 (concatD [prt 0 quant , doc (showString "disj") , prt 0 decl , doc (showString "|") , prt 0 exp])
+   DeclQuant _ quant decl exp -> prPrec i 0 (concatD [prt 0 quant , prt 0 decl , doc (showString "|") , prt 0 exp])
+   EGMax _ exp -> prPrec i 1 (concatD [doc (showString "max") , prt 2 exp])
+   EGMin _ exp -> prPrec i 1 (concatD [doc (showString "min") , prt 2 exp])
+   EIff _ exp0 exp -> prPrec i 1 (concatD [prt 1 exp0 , doc (showString "<=>") , prt 2 exp])
+   EImplies _ exp0 exp -> prPrec i 2 (concatD [prt 2 exp0 , doc (showString "=>") , prt 3 exp])
+   EOr _ exp0 exp -> prPrec i 3 (concatD [prt 3 exp0 , doc (showString "||") , prt 4 exp])
+   EXor _ exp0 exp -> prPrec i 4 (concatD [prt 4 exp0 , doc (showString "xor") , prt 5 exp])
+   EAnd _ exp0 exp -> prPrec i 5 (concatD [prt 5 exp0 , doc (showString "&&") , prt 6 exp])
+   ENeg _ exp -> prPrec i 6 (concatD [doc (showString "!") , prt 7 exp])
+   ELt _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "<") , prt 8 exp])
+   EGt _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString ">") , prt 8 exp])
+   EEq _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "=") , prt 8 exp])
+   ELte _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "<=") , prt 8 exp])
+   EGte _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString ">=") , prt 8 exp])
+   ENeq _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "!=") , prt 8 exp])
+   EIn _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "in") , prt 8 exp])
+   ENin _ exp0 exp -> prPrec i 7 (concatD [prt 7 exp0 , doc (showString "not") , doc (showString "in") , prt 8 exp])
+   QuantExp _ quant exp -> prPrec i 8 (concatD [prt 0 quant , prt 12 exp])
+   EAdd _ exp0 exp -> prPrec i 9 (concatD [prt 9 exp0 , doc (showString "+") , prt 10 exp])
+   ESub _ exp0 exp -> prPrec i 9 (concatD [prt 9 exp0 , doc (showString "-") , prt 10 exp])
+   EMul _ exp0 exp -> prPrec i 10 (concatD [prt 10 exp0 , doc (showString "*") , prt 11 exp])
+   EDiv _ exp0 exp -> prPrec i 10 (concatD [prt 10 exp0 , doc (showString "/") , prt 11 exp])
+   ESumSetExp _ exp -> prPrec i 11 (concatD [doc (showString "sum") , prt 12 exp])
+   ECSetExp _ exp -> prPrec i 11 (concatD [doc (showString "#") , prt 12 exp])
+   EMinExp _ exp -> prPrec i 11 (concatD [doc (showString "-") , prt 12 exp])
+   EImpliesElse _ exp0 exp1 exp -> prPrec i 12 (concatD [doc (showString "if") , prt 12 exp0 , doc (showString "then") , prt 12 exp1 , doc (showString "else") , prt 13 exp])
+   EInt _ posinteger -> prPrec i 13 (concatD [prt 0 posinteger])
+   EDouble _ posdouble -> prPrec i 13 (concatD [prt 0 posdouble])
+   EStr _ posstring -> prPrec i 13 (concatD [prt 0 posstring])
+   ESetExp _ setexp -> prPrec i 13 (concatD [prt 0 setexp])
 
   prtList es = case es of
    [] -> (concatD [])
@@ -332,46 +258,33 @@ 
 instance Print SetExp where
   prt i e = case e of
-   Union setexp0 setexp -> prPrec i 0 (concatD [prt 0 setexp0 , doc (showString "++") , prt 1 setexp])
-   PosUnion span setexp0 setexp -> prPrec i 0 (concatD [prt 0 span , prt 0 setexp0 , doc (showString "++") , prt 1 setexp])
-   UnionCom setexp0 setexp -> prPrec i 0 (concatD [prt 0 setexp0 , doc (showString ",") , prt 1 setexp])
-   PosUnionCom span setexp0 setexp -> prPrec i 0 (concatD [prt 0 span , prt 0 setexp0 , doc (showString ",") , prt 1 setexp])
-   Difference setexp0 setexp -> prPrec i 1 (concatD [prt 1 setexp0 , doc (showString "--") , prt 2 setexp])
-   PosDifference span setexp0 setexp -> prPrec i 1 (concatD [prt 0 span , prt 1 setexp0 , doc (showString "--") , prt 2 setexp])
-   Intersection setexp0 setexp -> prPrec i 2 (concatD [prt 2 setexp0 , doc (showString "&") , prt 3 setexp])
-   PosIntersection span setexp0 setexp -> prPrec i 2 (concatD [prt 0 span , prt 2 setexp0 , doc (showString "&") , prt 3 setexp])
-   Domain setexp0 setexp -> prPrec i 3 (concatD [prt 3 setexp0 , doc (showString "<:") , prt 4 setexp])
-   PosDomain span setexp0 setexp -> prPrec i 3 (concatD [prt 0 span , prt 3 setexp0 , doc (showString "<:") , prt 4 setexp])
-   Range setexp0 setexp -> prPrec i 4 (concatD [prt 4 setexp0 , doc (showString ":>") , prt 5 setexp])
-   PosRange span setexp0 setexp -> prPrec i 4 (concatD [prt 0 span , prt 4 setexp0 , doc (showString ":>") , prt 5 setexp])
-   Join setexp0 setexp -> prPrec i 5 (concatD [prt 5 setexp0 , doc (showString ".") , prt 6 setexp])
-   PosJoin span setexp0 setexp -> prPrec i 5 (concatD [prt 0 span , prt 5 setexp0 , doc (showString ".") , prt 6 setexp])
-   ClaferId name -> prPrec i 6 (concatD [prt 0 name])
-   PosClaferId span name -> prPrec i 6 (concatD [prt 0 span , prt 0 name])
+   Union _ setexp0 setexp -> prPrec i 0 (concatD [prt 0 setexp0 , doc (showString "++") , prt 1 setexp])
+   UnionCom _ setexp0 setexp -> prPrec i 0 (concatD [prt 0 setexp0 , doc (showString ",") , prt 1 setexp])
+   Difference _ setexp0 setexp -> prPrec i 1 (concatD [prt 1 setexp0 , doc (showString "--") , prt 2 setexp])
+   Intersection _ setexp0 setexp -> prPrec i 2 (concatD [prt 2 setexp0 , doc (showString "&") , prt 3 setexp])
+   Domain _ setexp0 setexp -> prPrec i 3 (concatD [prt 3 setexp0 , doc (showString "<:") , prt 4 setexp])
+   Range _ setexp0 setexp -> prPrec i 4 (concatD [prt 4 setexp0 , doc (showString ":>") , prt 5 setexp])
+   Join _ setexp0 setexp -> prPrec i 5 (concatD [prt 5 setexp0 , doc (showString ".") , prt 6 setexp])
+   ClaferId _ name -> prPrec i 6 (concatD [prt 0 name])
 
 
 instance Print Decl where
   prt i e = case e of
-   Decl locids setexp -> prPrec i 0 (concatD [prt 0 locids , doc (showString ":") , prt 0 setexp])
-   PosDecl span locids setexp -> prPrec i 0 (concatD [prt 0 span , prt 0 locids , doc (showString ":") , prt 0 setexp])
+   Decl _ locids setexp -> prPrec i 0 (concatD [prt 0 locids , doc (showString ":") , prt 0 setexp])
 
 
 instance Print Quant where
   prt i e = case e of
-   QuantNo  -> prPrec i 0 (concatD [doc (showString "no")])
-   PosQuantNo span -> prPrec i 0 (concatD [prt 0 span , doc (showString "no")])
-   QuantLone  -> prPrec i 0 (concatD [doc (showString "lone")])
-   PosQuantLone span -> prPrec i 0 (concatD [prt 0 span , doc (showString "lone")])
-   QuantOne  -> prPrec i 0 (concatD [doc (showString "one")])
-   PosQuantOne span -> prPrec i 0 (concatD [prt 0 span , doc (showString "one")])
-   QuantSome  -> prPrec i 0 (concatD [doc (showString "some")])
-   PosQuantSome span -> prPrec i 0 (concatD [prt 0 span , doc (showString "some")])
+   QuantNo _  -> prPrec i 0 (concatD [doc (showString "no")])
+   QuantNot _  -> prPrec i 0 (concatD [doc (showString "not")])
+   QuantLone _  -> prPrec i 0 (concatD [doc (showString "lone")])
+   QuantOne _  -> prPrec i 0 (concatD [doc (showString "one")])
+   QuantSome _  -> prPrec i 0 (concatD [doc (showString "some")])
 
 
 instance Print EnumId where
   prt i e = case e of
-   EnumIdIdent posident -> prPrec i 0 (concatD [prt 0 posident])
-   PosEnumIdIdent span posident -> prPrec i 0 (concatD [prt 0 span , prt 0 posident])
+   EnumIdIdent _ posident -> prPrec i 0 (concatD [prt 0 posident])
 
   prtList es = case es of
    [x] -> (concatD [prt 0 x])
@@ -379,8 +292,7 @@ 
 instance Print ModId where
   prt i e = case e of
-   ModIdIdent posident -> prPrec i 0 (concatD [prt 0 posident])
-   PosModIdIdent span posident -> prPrec i 0 (concatD [prt 0 span , prt 0 posident])
+   ModIdIdent _ posident -> prPrec i 0 (concatD [prt 0 posident])
 
   prtList es = case es of
    [x] -> (concatD [prt 0 x])
@@ -388,23 +300,10 @@ 
 instance Print LocId where
   prt i e = case e of
-   LocIdIdent posident -> prPrec i 0 (concatD [prt 0 posident])
-   PosLocIdIdent span posident -> prPrec i 0 (concatD [prt 0 span , prt 0 posident])
+   LocIdIdent _ posident -> prPrec i 0 (concatD [prt 0 posident])
 
   prtList es = case es of
    [x] -> (concatD [prt 0 x])
    x:xs -> (concatD [prt 0 x , doc (showString ";") , prt 0 xs])
-
-instance Print Pos where
-  prt i e = case e of
-   Pos n0 n -> prPrec i 0 (concatD [prt 0 n0 , prt 0 n])
-   PosPos span n0 n -> prPrec i 0 (concatD [prt 0 span , prt 0 n0 , prt 0 n])
-
-
-instance Print Span where
-  prt i e = case e of
-   Span pos0 pos -> prPrec i 0 (concatD [prt 0 pos0 , prt 0 pos])
-   PosSpan span pos0 pos -> prPrec i 0 (concatD [prt 0 span , prt 0 pos0 , prt 0 pos])
-
 
 
src/Language/Clafer/Generator/Alloy.hs view
@@ -103,7 +103,7 @@ 
 header :: ClaferArgs -> [(UID, Integer)] -> Concat
 header    args          scopes       = CString $ unlines
-    [ if Alloy42 `elem` (mode args) then "" else "open util/integer"
+    [ "open util/integer"
     , "pred show {}"
     , if (validate args) ||  (noalloyruncommand args)  
       then "" 
src/Language/Clafer/Generator/Choco.hs view
@@ -5,7 +5,7 @@ module Language.Clafer.Generator.Choco (genCModule) where
 
 import Control.Applicative
-import Control.Lens.Plated
+import Control.Lens.Plated hiding (rewrite)
 import Control.Monad
 import Data.Data.Lens
 import Data.List
@@ -121,15 +121,15 @@         where
             scopeMap = [uid' ++ ":" ++ show scope | (uid', scope) <- scopes, uid' /= "int"]
 
-    exps :: [IExp]
-    exps = universeOn biplate imodule
+    exps' :: [IExp]
+    exps' = universeOn biplate imodule
 
     stringLength :: IExp -> Maybe Int
     stringLength (IStr string) = Just $ length string
     stringLength _ = Nothing
 
     longestString :: Int
-    longestString = maximum $ 16 : mapMaybe stringLength exps
+    longestString = maximum $ 16 : mapMaybe stringLength exps'
                 
     genConcreteClafer :: IClafer -> Result
     genConcreteClafer IClafer{_uid, _card = Just _card, _gcard = Just (IGCard _ _gcard)} =
@@ -139,7 +139,9 @@                 case parentOf _uid of
                      "root" -> "Clafer"
                      puid   -> puid ++ ".addChild"
-                     
+    genConcreteClafer (IClafer _ _ Nothing _ _ _ _ _ _) = error "Choco.getConcreteClafer undefined"
+    genConcreteClafer (IClafer _ _ (Just (IGCard _ _)) _ _ _ Nothing _ _) = error "Choco.getConcreteClafer undefined"
+
     prop name value =
         case value of
                 Just value' -> "." ++ name ++ "(" ++ value' ++ ")"
@@ -255,7 +257,7 @@     genConstraintExp (IFunExp "sum" args')
         | [arg] <- args', PExp{_exp = IFunExp{_exps = [a, PExp{_exp = IClaferId{_sident = "ref"}}]}} <- rewrite arg =
             "sum(" ++ genConstraintPExp a ++ ")"
-        | otherwise = error "Unexpected sum argument."
+        | otherwise = error "Choco: Unexpected sum argument."
     genConstraintExp (IFunExp "+" args') =
 	(if _iType (head args') == Just TString then "concat" else "add") ++
             "(" ++ intercalate ", " (map genConstraintPExp args') ++ ")"
@@ -268,7 +270,7 @@         | otherwise                = _sident
     genConstraintExp (IInt val) = "constant(" ++ show val ++ ")"
     genConstraintExp (IStr val) = "constant(" ++ show val ++ ")"
-    genConstraintExp e = error $ "Unknown expression: " ++ show e
+    genConstraintExp (IDouble val) = "constant(" ++ show val ++ ")"
                 
     mapQuant INo = "none"
     mapQuant ISome = "some"
@@ -290,7 +292,7 @@     mapFunc ">=" = "greaterThanEqual"
     mapFunc "!=" = "notEqual"
     mapFunc "in" = "$in"
-    mapFunc "nin" = "notIn"
+    mapFunc "not in" = "notIn"
     mapFunc "+" = "add"
     mapFunc "*" = "mul"
     mapFunc "/" = "div"
@@ -298,7 +300,7 @@     mapFunc "--" = "diff"
     mapFunc "&" = "inter"
     mapFunc "=>else" = "ifThenElse"
-    mapFunc op' = error $ "Unknown op: " ++ op'
+    mapFunc op' = error $ "Choco: Unknown op: " ++ op'
     
 {-    sidentOf u = ident $ claferWithUid u
     scopeOf "integer" = undefined
src/Language/Clafer/Generator/Graph.hs view
@@ -24,7 +24,6 @@ 
 import Language.Clafer.Common(fst3,snd3,trd3)
 import Language.Clafer.Front.Absclafer
-import Language.Clafer.Front.Mapper(range)
 import Language.Clafer.Intermediate.Tracing
 import Language.Clafer.Intermediate.Intclafer
 import Language.Clafer.Generator.Html(genTooltip)
@@ -45,17 +44,15 @@ -- Simplified Notation Printer --
 --toplevel: (Top_level (Boolean), Maybe Topmost parent, Maybe immediate parent)         
 graphSimpleModule :: Module -> Map.Map Span [Ir] -> Bool -> String
-graphSimpleModule (Module [])                _     _        = ""
-graphSimpleModule (Module (x:xs))            irMap showRefs = graphSimpleDeclaration x (True, Nothing, Nothing) irMap showRefs ++ graphSimpleModule (Module xs) irMap showRefs
-graphSimpleModule (PosModule _ declarations) irMap showRefs = graphSimpleModule (Module declarations) irMap showRefs
+graphSimpleModule (Module _ [])                _     _        = ""
+graphSimpleModule (Module s (x:xs))            irMap showRefs = graphSimpleDeclaration x (True, Nothing, Nothing) irMap showRefs ++ graphSimpleModule (Module s xs) irMap showRefs
 
 graphSimpleDeclaration :: Declaration
                           -> (Bool, Maybe String, Maybe String)
                           -> Map.Map Span [Ir]
                           -> Bool
                           -> String
-graphSimpleDeclaration (ElementDecl element)      topLevel irMap showRefs = graphSimpleElement element topLevel irMap showRefs
-graphSimpleDeclaration (PosElementDecl _ element) topLevel irMap showRefs = graphSimpleDeclaration (ElementDecl element) topLevel irMap showRefs
+graphSimpleDeclaration (ElementDecl _ element)      topLevel irMap showRefs = graphSimpleElement element topLevel irMap showRefs
 graphSimpleDeclaration _                          _        _     _        = ""
 
 graphSimpleElement :: Element
@@ -63,10 +60,8 @@                       -> Map.Map Span [Ir]
                       -> Bool
                       -> String
-graphSimpleElement (Subclafer clafer)                     topLevel irMap showRefs = graphSimpleClafer clafer topLevel irMap showRefs
-graphSimpleElement (PosSubclafer _ subclafer)             topLevel irMap showRefs = graphSimpleElement (Subclafer subclafer) topLevel irMap showRefs
-graphSimpleElement (ClaferUse name _ _)         topLevel irMap _        = if snd3 topLevel == Nothing then "" else "\"" ++ fromJust (snd3 topLevel) ++ "\" -> \"" ++ graphSimpleName name topLevel irMap ++ "\" [arrowhead=vee arrowtail=diamond dir=both style=solid constraint=true weight=5 minlen=2 arrowsize=0.6 penwidth=0.5 ];\n"
-graphSimpleElement (PosClaferUse s _ _ _) topLevel irMap _        = if snd3 topLevel == Nothing then "" else "\"" ++ fromJust (snd3 topLevel) ++ "\" -> \"" ++ getUseId s irMap ++ "\" [arrowhead=vee arrowtail=diamond dir=both style=solid constraint=true weight=5 minlen=2 arrowsize=0.6 penwidth=0.5 ];\n"
+graphSimpleElement (Subclafer _ clafer) topLevel irMap showRefs = graphSimpleClafer clafer topLevel irMap showRefs
+graphSimpleElement (ClaferUse s _ _ _)  topLevel irMap _        = if snd3 topLevel == Nothing then "" else "\"" ++ fromJust (snd3 topLevel) ++ "\" -> \"" ++ getUseId s irMap ++ "\" [arrowhead=vee arrowtail=diamond dir=both style=solid constraint=true weight=5 minlen=2 arrowsize=0.6 penwidth=0.5 ];\n"
 graphSimpleElement _ _ _ _ = ""
 
 graphSimpleElements :: Elements
@@ -74,19 +69,16 @@                       -> Map.Map Span [Ir]
                       -> Bool
                       -> String
-graphSimpleElements ElementsEmpty                _        _     _        = ""
-graphSimpleElements (PosElementsEmpty _)         topLevel irMap showRefs = graphSimpleElements ElementsEmpty topLevel irMap showRefs
-graphSimpleElements (ElementsList es)      topLevel irMap showRefs = concatMap (\x -> graphSimpleElement x topLevel irMap showRefs ++ "\n") es
-graphSimpleElements (PosElementsList _ es) topLevel irMap showRefs = graphSimpleElements (ElementsList es) topLevel irMap showRefs
+graphSimpleElements (ElementsEmpty _)                _        _     _        = ""
+graphSimpleElements (ElementsList _ es)      topLevel irMap showRefs = concatMap (\x -> graphSimpleElement x topLevel irMap showRefs ++ "\n") es
 
 graphSimpleClafer :: Clafer
                       -> (Bool, Maybe String, Maybe String)
                       -> Map.Map Span [Ir]
                       -> Bool
                       -> String 
-graphSimpleClafer (Clafer _ _ _ _ _ _ _)         _        _     _ = ""
-graphSimpleClafer (PosClafer s abstract gCard id' super' crd init' es) topLevel irMap showRefs
-  | fst3 topLevel == True = let {tooltip = genTooltip (Module [ElementDecl (Subclafer (Clafer abstract gCard id' super' crd init' es))]) irMap;
+graphSimpleClafer (Clafer s abstract gCard id' super' crd init' es) topLevel irMap showRefs
+  | fst3 topLevel == True = let {tooltip = genTooltip (Module s [ElementDecl s (Subclafer s (Clafer s abstract gCard id' super' crd init' es))]) irMap;
                                uid' = getDivId s irMap} in
                              "\"" ++ uid' ++ "\" [label=\"" ++ (head $ lines tooltip) ++ "\" URL=\"#" ++ uid' ++ "\" tooltip=\"" ++ htmlNewlines tooltip ++ "\"];\n"
                              ++ graphSimpleSuper super' (True, Just uid', Just uid') irMap showRefs ++ graphSimpleElements es (False, Just uid', Just uid') irMap showRefs
@@ -98,36 +90,29 @@                   -> Map.Map Span [Ir]
                   -> Bool
                   -> String
-graphSimpleSuper SuperEmpty _ _ _ = ""
-graphSimpleSuper (PosSuperEmpty _) topLevel irMap showRefs = graphSimpleSuper SuperEmpty topLevel irMap showRefs
-graphSimpleSuper (SuperSome superHow setExp) topLevel irMap showRefs = let {parent [] = "error";
+graphSimpleSuper (SuperEmpty _) _ _ _ = ""
+graphSimpleSuper (SuperSome _ superHow setExp) topLevel irMap showRefs = let {parent [] = "error";
                                                             parent (uid'@('c':xs):xss) = if '_' `elem` xs then uid' else parent xss;
                                                             parent (_:xss) = parent xss;
                                                             super' = parent $ graphSimpleSetExp setExp topLevel irMap} in
                                                             if super' == "error" then "" else "\"" ++ fromJust (snd3 topLevel) ++ "\" -> \"" ++ parent (graphSimpleSetExp setExp topLevel irMap) ++ "\"" ++ graphSimpleSuperHow superHow topLevel irMap showRefs
-graphSimpleSuper (PosSuperSome _ superHow setExp) topLevel irMap showRefs = graphSimpleSuper (SuperSome superHow setExp) topLevel irMap showRefs
 
 graphSimpleSuperHow :: SuperHow -> (Bool, Maybe String, Maybe String) -> Map.Map Span [Ir] -> Bool -> String
-graphSimpleSuperHow SuperColon topLevel _ _ = " [" ++ if fst3 topLevel == True 
+graphSimpleSuperHow (SuperColon _) topLevel _ _ = " [" ++ if fst3 topLevel == True 
                                                                  then "arrowhead=onormal constraint=true weight=100];\n" 
                                                                  else "arrowhead=vee arrowtail=diamond dir=both style=solid weight=10 color=gray arrowsize=0.6 minlen=2 penwidth=0.5 constraint=true];\n"
-graphSimpleSuperHow (PosSuperColon _) topLevel irMap showRefs  = graphSimpleSuperHow SuperColon topLevel irMap showRefs
-graphSimpleSuperHow SuperArrow topLevel _ showRefs = " [arrowhead=vee arrowsize=0.6 penwidth=0.5 constraint=true weight=10 color=" ++ refColour showRefs ++ " fontcolor=" ++ refColour showRefs ++ (if fst3 topLevel == True then "" else " label=" ++ (fromJust $ trd3 topLevel)) ++ "];\n"
-graphSimpleSuperHow (PosSuperArrow _) topLevel irMap showRefs = graphSimpleSuperHow SuperArrow topLevel irMap showRefs
-graphSimpleSuperHow SuperMArrow topLevel _ showRefs = " [arrowhead=veevee arrowsize=0.6 minlen=1.5 penwidth=0.5 constraint=true weight=10 color=" ++ refColour showRefs ++ " fontcolor=" ++ refColour showRefs ++ (if fst3 topLevel == True then "" else " label=" ++ (fromJust $ trd3 topLevel)) ++ "];\n"
-graphSimpleSuperHow (PosSuperMArrow _) topLevel irMap showRefs = graphSimpleSuperHow SuperMArrow topLevel irMap showRefs  
+graphSimpleSuperHow (SuperArrow _) topLevel _ showRefs = " [arrowhead=vee arrowsize=0.6 penwidth=0.5 constraint=true weight=10 color=" ++ refColour showRefs ++ " fontcolor=" ++ refColour showRefs ++ (if fst3 topLevel == True then "" else " label=" ++ (fromJust $ trd3 topLevel)) ++ "];\n"
+graphSimpleSuperHow (SuperMArrow _) topLevel _ showRefs = " [arrowhead=veevee arrowsize=0.6 minlen=1.5 penwidth=0.5 constraint=true weight=10 color=" ++ refColour showRefs ++ " fontcolor=" ++ refColour showRefs ++ (if fst3 topLevel == True then "" else " label=" ++ (fromJust $ trd3 topLevel)) ++ "];\n"
 
 refColour :: Bool -> String 
 refColour True = "lightgray" 
 refColour False = "transparent"
 
 graphSimpleName :: Name -> (Bool, Maybe String, Maybe String) -> Map.Map Span [Ir] -> String
-graphSimpleName (Path modids) topLevel irMap = unwords $ map (\x -> graphSimpleModId x topLevel irMap) modids
-graphSimpleName (PosPath _ modids) topLevel irMap = graphSimpleName (Path modids) topLevel irMap
+graphSimpleName (Path _ modids) topLevel irMap = unwords $ map (\x -> graphSimpleModId x topLevel irMap) modids
 
 graphSimpleModId :: ModId -> (Bool, Maybe String, Maybe String) -> Map.Map Span [Ir] -> String
-graphSimpleModId (ModIdIdent posident) _ irMap = graphSimplePosIdent posident irMap
-graphSimpleModId (PosModIdIdent _ posident) topLevel irMap = graphSimpleModId (ModIdIdent posident) topLevel irMap
+graphSimpleModId (ModIdIdent _ posident) _ irMap = graphSimplePosIdent posident irMap
 
 graphSimplePosIdent :: PosIdent -> Map.Map Span [Ir] -> String
 graphSimplePosIdent (PosIdent (pos, id')) irMap = getUid (PosIdent (pos, id')) irMap
@@ -147,22 +132,14 @@ graphSimpleExInteger _ _ _ = ""-}
 
 graphSimpleSetExp :: SetExp -> (Bool, Maybe String, Maybe String) -> Map.Map Span [Ir] -> [String]
-graphSimpleSetExp (ClaferId name) topLevel irMap = [graphSimpleName name topLevel irMap]
-graphSimpleSetExp (PosClaferId _ name) topLevel irMap = graphSimpleSetExp (ClaferId name) topLevel irMap
-graphSimpleSetExp (Union set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosUnion _ set1 set2) topLevel irMap = graphSimpleSetExp (Union set1 set2) topLevel irMap
-graphSimpleSetExp (UnionCom set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosUnionCom _ set1 set2) topLevel irMap = graphSimpleSetExp (UnionCom set1 set2) topLevel irMap
-graphSimpleSetExp (Difference set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosDifference _ set1 set2) topLevel irMap = graphSimpleSetExp (Difference set1 set2) topLevel irMap
-graphSimpleSetExp (Intersection set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosIntersection _ set1 set2) topLevel irMap = graphSimpleSetExp (Intersection set1 set2) topLevel irMap
-graphSimpleSetExp (Domain set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosDomain _ set1 set2) topLevel irMap = graphSimpleSetExp (Domain set1 set2) topLevel irMap
-graphSimpleSetExp (Range set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosRange _ set1 set2) topLevel irMap = graphSimpleSetExp (Range set1 set2) topLevel irMap
-graphSimpleSetExp (Join set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
-graphSimpleSetExp (PosJoin _ set1 set2) topLevel irMap = graphSimpleSetExp (Join set1 set2) topLevel irMap
+graphSimpleSetExp (ClaferId _ name) topLevel irMap = [graphSimpleName name topLevel irMap]
+graphSimpleSetExp (Union _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
+graphSimpleSetExp (UnionCom _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
+graphSimpleSetExp (Difference _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
+graphSimpleSetExp (Intersection _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
+graphSimpleSetExp (Domain _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
+graphSimpleSetExp (Range _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
+graphSimpleSetExp (Join _ set1 set2) topLevel irMap = graphSimpleSetExp set1 topLevel irMap ++ graphSimpleSetExp set2 topLevel irMap
 
 {-graphSimpleEnumId :: EnumId -> (Bool, Maybe String, Maybe String) -> Map.Map Span [Ir] -> String
 graphSimpleEnumId (EnumIdIdent posident) _ irMap = graphSimplePosIdent posident irMap
@@ -171,33 +148,27 @@ -- CVL Printer --
 --parent is Maybe the uid of the immediate parent
 graphCVLModule :: Module -> Map.Map Span [Ir] -> String
-graphCVLModule (Module [])     _ = ""
-graphCVLModule (Module (x:xs)) irMap = graphCVLDeclaration x Nothing irMap ++ graphCVLModule (Module xs) irMap
-graphCVLModule (PosModule _ declarations) irMap = graphCVLModule (Module declarations) irMap
+graphCVLModule (Module _ [])     _ = ""
+graphCVLModule (Module s (x:xs)) irMap = graphCVLDeclaration x Nothing irMap ++ graphCVLModule (Module s xs) irMap
 
 graphCVLDeclaration :: Declaration -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLDeclaration (ElementDecl element)      parent irMap = graphCVLElement element parent irMap
-graphCVLDeclaration (PosElementDecl _ element) parent irMap = graphCVLDeclaration (ElementDecl element) parent irMap
+graphCVLDeclaration (ElementDecl _ element)      parent irMap = graphCVLElement element parent irMap
 graphCVLDeclaration _                          _        _     = ""
 
 graphCVLElement :: Element -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLElement (Subclafer clafer)  parent irMap = graphCVLClafer clafer parent irMap
-graphCVLElement (PosSubclafer _ subclafer) parent irMap = graphCVLElement (Subclafer subclafer) parent irMap
-graphCVLElement (ClaferUse name _ _) parent irMap = if parent == Nothing then "" else "?" ++ " -> " ++ graphCVLName name parent irMap ++ " [arrowhead = onormal style = dashed constraint = false];\n"
-graphCVLElement (PosClaferUse s _ _ _) parent irMap = if parent == Nothing then "" else "?" ++ " -> " ++ getUseId s irMap ++ " [arrowhead = onormal style = dashed constraint = false];\n"
-graphCVLElement (Subconstraint constraint) parent irMap = graphCVLConstraint constraint parent irMap
-graphCVLElement (PosSubconstraint _ constraint) parent irMap = graphCVLElement (Subconstraint constraint) parent irMap
-graphCVLElement _ _ _ = ""
+graphCVLElement (Subclafer _ clafer)  parent irMap = graphCVLClafer clafer parent irMap
+--graphCVLElement (ClaferUse _ name _ _) parent irMap = if parent == Nothing then "" else "?" ++ " -> " ++ graphCVLName name parent irMap ++ " [arrowhead = onormal style = dashed constraint = false];\n"
+graphCVLElement (ClaferUse s _ _ _) parent irMap = if parent == Nothing then "" else "?" ++ " -> " ++ getUseId s irMap ++ " [arrowhead = onormal style = dashed constraint = false];\n"
+graphCVLElement (Subconstraint _ constraint) parent irMap = graphCVLConstraint constraint parent irMap
+graphCVLElement (Subgoal _ constraint) parent irMap = graphCVLGoal constraint parent irMap
+graphCVLElement (Subsoftconstraint _ constraint) parent irMap = graphCVLSoftConstraint constraint parent irMap
 
 graphCVLElements :: Elements -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLElements ElementsEmpty _ _ = ""
-graphCVLElements (PosElementsEmpty _) parent irMap = graphCVLElements ElementsEmpty parent irMap
-graphCVLElements (ElementsList es) parent irMap = concatMap (\x -> graphCVLElement x parent irMap  ++ "\n") es
-graphCVLElements (PosElementsList _ es) parent irMap = graphCVLElements (ElementsList es) parent irMap 
+graphCVLElements (ElementsEmpty _) _ _ = ""
+graphCVLElements (ElementsList _ es) parent irMap = concatMap (\x -> graphCVLElement x parent irMap  ++ "\n") es
 
 graphCVLClafer :: Clafer -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLClafer (Clafer _ _ _ _ _ _ _) _ _ = ""
-graphCVLClafer (PosClafer s _ gCard _ super' crd _ es) parent irMap
+graphCVLClafer (Clafer s _ gCard _ super' crd _ es) parent irMap
    = let {{-tooltip = genTooltip (Module [ElementDecl (Subclafer (Clafer abstract gCard id' super' crd init' es))]) irMap;-}
           uid' = getDivId s irMap;
           gcrd = graphCVLGCard gCard parent irMap;
@@ -209,73 +180,63 @@      ++ graphCVLElements es (if gcrd == "" then (Just uid') else (Just $ "g" ++ uid')) irMap
 
 graphCVLSuper :: Super -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLSuper SuperEmpty _ _ = ""
-graphCVLSuper (PosSuperEmpty _) parent irMap = graphCVLSuper SuperEmpty parent irMap
-graphCVLSuper (SuperSome superHow setExp) parent irMap = graphCVLSuperHow superHow ++ concat (graphCVLSetExp setExp parent irMap)
-graphCVLSuper (PosSuperSome _ superHow setExp) parent irMap = graphCVLSuper (SuperSome superHow setExp) parent irMap
+graphCVLSuper (SuperEmpty _) _ _ = ""
+graphCVLSuper (SuperSome _ superHow setExp) parent irMap = graphCVLSuperHow superHow ++ concat (graphCVLSetExp setExp parent irMap)
 
 graphCVLSuperHow :: SuperHow -> String
-graphCVLSuperHow SuperColon = ":"
-graphCVLSuperHow (PosSuperColon _) = ":"
-graphCVLSuperHow SuperArrow = "->"
-graphCVLSuperHow (PosSuperArrow _) = "->"
-graphCVLSuperHow SuperMArrow = "->>"
-graphCVLSuperHow (PosSuperMArrow _) = "->>"
+graphCVLSuperHow (SuperColon _)  = ":"
+graphCVLSuperHow (SuperArrow _)  = "->"
+graphCVLSuperHow (SuperMArrow _) = "->>"
 
 graphCVLName :: Name -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLName (Path modids) parent irMap = unwords $ map (\x -> graphCVLModId x parent irMap) modids
-graphCVLName (PosPath _ modids) parent irMap = graphCVLName (Path modids) parent irMap
+graphCVLName (Path _ modids) parent irMap = unwords $ map (\x -> graphCVLModId x parent irMap) modids
 
 graphCVLModId :: ModId -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLModId (ModIdIdent posident) _ irMap = graphCVLPosIdent posident irMap
-graphCVLModId (PosModIdIdent _ posident) parent irMap = graphCVLModId (ModIdIdent posident) parent irMap
+graphCVLModId (ModIdIdent _ posident) _ irMap = graphCVLPosIdent posident irMap
 
 graphCVLPosIdent :: PosIdent -> Map.Map Span [Ir] -> String
 graphCVLPosIdent (PosIdent (pos, id')) irMap = getUid (PosIdent (pos, id')) irMap
 
 graphCVLConstraint :: Constraint -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLConstraint (Constraint _) _ _ = ""
-graphCVLConstraint (PosConstraint s exps') parent irMap = let body' = htmlNewlines $ genTooltip (Module [ElementDecl (Subconstraint (Constraint exps'))]) irMap;
+graphCVLConstraint (Constraint s exps') parent irMap = let body' = htmlNewlines $ genTooltip (Module s [ElementDecl s (Subconstraint s (Constraint s exps'))]) irMap;
                                                                        uid' = "\"" ++ getExpId s irMap ++ "\""
                                                                     in uid' ++ " [label=\"" ++ body' ++ "\" shape=parallelogram];\n" ++
                                                                       if parent == Nothing then "" else uid' ++ " -> \"" ++ fromJust parent ++ "\";\n"
+
+graphCVLSoftConstraint :: SoftConstraint -> Maybe String -> Map.Map Span [Ir] -> String
+graphCVLSoftConstraint (SoftConstraint s exps') parent irMap = let body' = htmlNewlines $ genTooltip (Module s [ElementDecl s (Subsoftconstraint s (SoftConstraint s exps'))]) irMap;
+                                                                       uid' = "\"" ++ getExpId s irMap ++ "\""
+                                                                    in uid' ++ " [label=\"" ++ body' ++ "\" shape=parallelogram];\n" ++
+                                                                      if parent == Nothing then "" else uid' ++ " -> \"" ++ fromJust parent ++ "\";\n"
+
+graphCVLGoal :: Goal -> Maybe String -> Map.Map Span [Ir] -> String
+graphCVLGoal (Goal s exps') parent irMap = let body' = htmlNewlines $ genTooltip (Module s [ElementDecl s (Subgoal s (Goal s exps'))]) irMap;
+                                                                       uid' = "\"" ++ getExpId s irMap ++ "\""
+                                                                    in uid' ++ " [label=\"" ++ body' ++ "\" shape=parallelogram];\n" ++
+                                                                      if parent == Nothing then "" else uid' ++ " -> \"" ++ fromJust parent ++ "\";\n"                                                                      
+
 graphCVLCard :: Card -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLCard  CardEmpty _ _ = "1..1"
-graphCVLCard  CardLone _ _ =  "0..1"
-graphCVLCard  CardSome _ _ =  "1..*"
-graphCVLCard  CardAny _ _ =   "0..*"
-graphCVLCard  (CardNum (PosInteger (_, n))) _ _ = n ++ ".." ++ n
-graphCVLCard  (CardInterval ncard) parent irMap = graphCVLNCard ncard parent irMap
-graphCVLCard  (PosCardEmpty _) _ _ = "1..1"
-graphCVLCard  (PosCardLone _) _ _ =  "0..1"
-graphCVLCard  (PosCardSome _) _ _ =  "1..*"
-graphCVLCard  (PosCardAny _) _ _ =    "0..*"
-graphCVLCard  (PosCardNum _ (PosInteger (_, n))) _ _ = n ++ ".." ++ n
-graphCVLCard  (PosCardInterval _ ncard) parent irMap = graphCVLNCard ncard parent irMap
+graphCVLCard  (CardEmpty _) _ _ = "1..1"
+graphCVLCard  (CardLone _) _ _ =  "0..1"
+graphCVLCard  (CardSome _) _ _ =  "1..*"
+graphCVLCard  (CardAny _) _ _ =    "0..*"
+graphCVLCard  (CardNum _ (PosInteger (_, n))) _ _ = n ++ ".." ++ n
+graphCVLCard  (CardInterval _ ncard) parent irMap = graphCVLNCard ncard parent irMap
 
 graphCVLNCard :: NCard -> Maybe String -> Map.Map Span [Ir] -> String 
-graphCVLNCard (NCard (PosInteger (_, num)) exInteger) parent irMap = num ++ ".." ++ graphCVLExInteger exInteger parent irMap
-graphCVLNCard (PosNCard _ posInteger exInteger) parent irMap = graphCVLNCard (NCard posInteger exInteger) parent irMap
+graphCVLNCard (NCard _ (PosInteger (_, num)) exInteger) parent irMap = num ++ ".." ++ graphCVLExInteger exInteger parent irMap
 
 graphCVLExInteger :: ExInteger -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLExInteger ExIntegerAst _ _ = "*"
-graphCVLExInteger (PosExIntegerAst _) parent irMap = graphCVLExInteger ExIntegerAst parent irMap
-graphCVLExInteger (ExIntegerNum (PosInteger(_, num))) _ _ = num
-graphCVLExInteger (PosExIntegerNum _ posInteger) parent irMap = graphCVLExInteger (ExIntegerNum posInteger) parent irMap
+graphCVLExInteger (ExIntegerAst _) _ _ = "*"
+graphCVLExInteger (ExIntegerNum _ (PosInteger(_, num))) _ _ = num
 
 graphCVLGCard :: GCard -> Maybe String -> Map.Map Span [Ir] -> String
-graphCVLGCard (GCardInterval ncard) parent irMap = graphCVLNCard ncard parent irMap
-graphCVLGCard (PosGCardInterval _ ncard) parent irMap = graphCVLNCard ncard parent irMap
-graphCVLGCard GCardEmpty _ _ = ""
-graphCVLGCard (PosGCardEmpty _) _ _ = ""
-graphCVLGCard GCardXor _ _ = "1..1"
-graphCVLGCard (PosGCardXor _) _ _ = "1..1"
-graphCVLGCard GCardOr _ _= "1..*"
-graphCVLGCard (PosGCardOr _) _ _ = "1..*"
-graphCVLGCard GCardMux _ _ = "0..1"
-graphCVLGCard (PosGCardMux _) _ _ = "0..1"
-graphCVLGCard GCardOpt _ _ = ""
-graphCVLGCard (PosGCardOpt _) _ _ = ""
+graphCVLGCard (GCardInterval _ ncard) parent irMap = graphCVLNCard ncard parent irMap
+graphCVLGCard (GCardEmpty _) _ _ = ""
+graphCVLGCard (GCardXor _) _ _ = "1..1"
+graphCVLGCard (GCardOr _) _ _ = "1..*"
+graphCVLGCard (GCardMux _) _ _ = "0..1"
+graphCVLGCard (GCardOpt _) _ _ = ""
 
 
 {-graphCVLDecl _ _ _ = ""
@@ -288,42 +249,26 @@ graphCVLAbstract _ _ _ = ""-}
 
 graphCVLSetExp :: SetExp -> Maybe String -> Map.Map Span [Ir] -> [String]
-graphCVLSetExp (ClaferId name) parent irMap = [graphCVLName name parent irMap]
-graphCVLSetExp (PosClaferId _ name) parent irMap = graphCVLSetExp (ClaferId name) parent irMap
-graphCVLSetExp (Union set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosUnion _ set1 set2) parent irMap = graphCVLSetExp (Union set1 set2) parent irMap
-graphCVLSetExp (UnionCom set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosUnionCom _ set1 set2) parent irMap = graphCVLSetExp (UnionCom set1 set2) parent irMap
-graphCVLSetExp (Difference set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosDifference _ set1 set2) parent irMap = graphCVLSetExp (Difference set1 set2) parent irMap
-graphCVLSetExp (Intersection set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosIntersection _ set1 set2) parent irMap = graphCVLSetExp (Intersection set1 set2) parent irMap
-graphCVLSetExp (Domain set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosDomain _ set1 set2) parent irMap = graphCVLSetExp (Domain set1 set2) parent irMap
-graphCVLSetExp (Range set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosRange _ set1 set2) parent irMap = graphCVLSetExp (Range set1 set2) parent irMap
-graphCVLSetExp (Join set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
-graphCVLSetExp (PosJoin _ set1 set2) parent irMap = graphCVLSetExp (Join set1 set2) parent irMap
+graphCVLSetExp (ClaferId _ name) parent irMap = [graphCVLName name parent irMap]
+graphCVLSetExp (Union _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
+graphCVLSetExp (UnionCom _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
+graphCVLSetExp (Difference _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
+graphCVLSetExp (Intersection _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
+graphCVLSetExp (Domain _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
+graphCVLSetExp (Range _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
+graphCVLSetExp (Join _ set1 set2) parent irMap = graphCVLSetExp set1 parent irMap ++ graphCVLSetExp set2 parent irMap
 
 {-graphCVLEnumId (EnumIdIdent posident) _ irMap = graphCVLPosIdent posident irMap
 graphCVLEnumId (PosEnumIdIdent _ posident) parent irMap = graphCVLEnumId (EnumIdIdent posident) parent irMap-}
 
 choiceCard :: Card -> Bool
-choiceCard CardEmpty = True
-choiceCard (PosCardEmpty _) = choiceCard CardEmpty
-choiceCard CardLone = True
-choiceCard (PosCardLone _) = choiceCard CardLone
-choiceCard (CardInterval nCard) = case nCard of
-  PosNCard _ (PosInteger (_, low)) exInteger -> choiceCard' low exInteger
-  NCard (PosInteger (_, low)) exInteger -> choiceCard' low exInteger
-  where choiceCard' low exInteger = if low == "0" || low == "1"
+choiceCard (CardEmpty _) = True
+choiceCard (CardLone _) = True
+choiceCard (CardInterval _ (NCard _ (PosInteger (_, low)) exInteger)) = if low == "0" || low == "1"
                                     then case exInteger of
-                                      ExIntegerAst -> False
-                                      PosExIntegerAst _ -> False
-                                      ExIntegerNum (PosInteger (_, high)) -> high == "0" || high == "1"
-                                      PosExIntegerNum _ (PosInteger (_, high)) -> high == "0" || high == "1"
+                                      (ExIntegerAst _) -> False
+                                      (ExIntegerNum _ (PosInteger (_, high))) -> high == "0" || high == "1"
                                     else False
-choiceCard (PosCardInterval _ nCard) = choiceCard (CardInterval nCard)
 choiceCard _ = False
 
 lowerCard :: Card -> String
@@ -338,9 +283,9 @@ rest (_:xs) = xs
 
 getUid :: PosIdent -> Map.Map Span [Ir] -> String
-getUid (PosIdent (pos, id')) irMap = if Map.lookup (range (PosIdent (pos, id'))) irMap == Nothing
+getUid (PosIdent (pos, id')) irMap = if Map.lookup (getSpan (PosIdent (pos, id'))) irMap == Nothing
                         then id'
-                        else let IRPExp pexp = head $ fromJust $ Map.lookup (range (PosIdent (pos, id'))) irMap in
+                        else let IRPExp pexp = head $ fromJust $ Map.lookup (getSpan (PosIdent (pos, id'))) irMap in
                           findUid id' $ getIdentPExp pexp
                           where {getIdentPExp (PExp _ _ _ exp') = getIdentIExp exp';
                                  getIdentIExp (IFunExp _ exps') = concatMap getIdentPExp exps';
src/Language/Clafer/Generator/Html.hs view
@@ -39,7 +39,6 @@ import Language.ClaferT
 import Language.Clafer.Front.Absclafer
 import Language.Clafer.Front.LayoutResolver(revertLayout)
-import Language.Clafer.Front.Mapper(range)
 import Language.Clafer.Intermediate.Tracing
 import Language.Clafer.Intermediate.Intclafer
 import Data.List (intersperse,genericSplitAt)
@@ -64,8 +63,6 @@                 '/':'*':_:[]   -> findAll row (cs', concat [comments, printStandaloneComment comment ++ "\n"])
                 _      -> (cs', "Improper form of comment.")-- Should not happen. Bug.
             | otherwise  = ((c':cs'), comments)
-          findAll row ((_:cs'), comments) = findAll row (cs', comments)
-printPreComment _ cs = (cs,"")
 printComment :: Span -> [(Span, String)] -> ([(Span, String)], String)
 printComment _ [] = ([],[])
 printComment (Span (Pos row _) _) (c@(Span (Pos row' col') _, comment):cs)
@@ -78,7 +75,6 @@         _      -> (cs, "Improper form of comment.")-- Should not happen. Bug.
   | otherwise = (c:cs, "")
   where trim' = let f = reverse. dropWhile isSpace in f . f
-printComment _ cs = (cs,"")
 printStandaloneComment :: String -> String
 printStandaloneComment comment = "<div class=\"standalonecomment\">" ++ comment ++ "</div>"
 printInlineComment :: String -> String
@@ -95,21 +91,11 @@ genTooltip m ir = unlines $ filter (\x -> trim x /= []) $ lines $ cleanOutput $ revertLayout $ printModule m ir False
 
 printModule :: Module -> Map.Map Span [Ir] -> Bool -> String
-printModule (Module [])     _ _ = ""
-printModule (Module (x:xs)) irMap html = (printDeclaration x 0 irMap html []) ++ printModule (Module xs) irMap html
-printModule (PosModule _ declarations) irMap html = printModule (Module declarations) irMap html
+printModule (Module _ [])     _ _ = ""
+printModule (Module s (x:xs)) irMap html = (printDeclaration x 0 irMap html []) ++ printModule (Module s xs) irMap html
 
 printDeclaration :: Declaration -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printDeclaration (EnumDecl posIdent enumIds) indent irMap html comments = 
-  let (PosIdent (_, _)) = posIdent in
-    printIndentId 0 html ++
-    (while html "<span class=\"keyword\">") ++ "enum" ++ (while html "</span>") ++ 
-    " " ++ 
-    (printPosIdent posIdent Nothing html) ++ 
-    " = " ++ 
-    (concat $ intersperse " | " (map (\x -> printEnumId x indent irMap html comments) enumIds)) ++
-    printIndentEnd html
-printDeclaration (PosEnumDecl s posIdent enumIds)  indent irMap html comments = 
+printDeclaration (EnumDecl s posIdent enumIds)  indent irMap html comments = 
     preComments ++
     printIndentId 0 html ++
     (while html "<span class=\"keyword\">") ++ "enum" ++ (while html "</span>") ++ 
@@ -123,20 +109,12 @@     uid' = getUid posIdent irMap;
     (comments', preComments) = printPreComment s comments;
     (_, comment) = printComment s comments'
-printDeclaration (ElementDecl element)      indent irMap html comments = printElement element indent irMap html comments
-printDeclaration (PosElementDecl _ element) indent irMap html comments = printDeclaration (ElementDecl element) indent irMap html comments
+printDeclaration (ElementDecl _ element) indent irMap html comments = printElement element indent irMap html comments
 
 printElement :: Element -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printElement (Subclafer clafer) indent irMap html comments = printClafer clafer indent irMap html comments
-printElement (PosSubclafer _ subclafer) indent irMap html comments = printElement (Subclafer subclafer) indent irMap html comments
+printElement (Subclafer _ clafer) indent irMap html comments = printClafer clafer indent irMap html comments
 
-printElement (ClaferUse name crd es) indent irMap html comments = 
-  printIndent indent html ++ 
-  "`" ++ printName name indent irMap html comments ++ 
-  printCard crd ++ 
-  printIndentEnd html ++
-  printElements es indent irMap html comments
-printElement (PosClaferUse s name crd es) indent irMap html comments = 
+printElement (ClaferUse s name crd es) indent irMap html comments = 
   preComments ++ 
   printIndentId indent html ++
   "`" ++ (while html ("<a href=\"#" ++ superId ++ "\"><span class=\"reference\">")) ++ 
@@ -151,23 +129,17 @@     (comments', preComments) = printPreComment s comments;
     (comments'', comment) = printComment s comments' 
 
-printElement (Subgoal goal) indent irMap html comments = printGoal goal indent irMap html comments
-printElement (PosSubgoal s goal) indent irMap html comments = 
+printElement (Subgoal s goal) indent irMap html comments = 
   preComments ++ 
   printIndent 0 html ++
-  printElement (Subgoal goal) indent irMap html comments'' ++ 
+  printGoal goal indent irMap html comments'' ++
   comment ++ 
   printIndentEnd html
   where
    (comments', preComments) = printPreComment s comments; 
    (comments'', comment) = printComment s comments' 
 
-printElement (Subconstraint constraint) indent irMap html comments =
-    printIndent indent html ++
-    printConstraint constraint indent irMap html comments ++
-    printIndentEnd html
-
-printElement (PosSubconstraint s constraint) indent irMap html comments =
+printElement (Subconstraint s constraint) indent irMap html comments =
     preComments ++
     printIndent indent html ++ 
     printConstraint constraint indent irMap html comments'' ++
@@ -177,12 +149,7 @@     (comments', preComments) = printPreComment s comments;
     (comments'', comment) = printComment s comments' 
 
-printElement (Subsoftconstraint constraint) indent irMap html comments =
-    printIndent indent html ++
-    printSoftConstraint constraint indent irMap html comments ++
-    printIndentEnd html
-
-printElement (PosSubsoftconstraint s constraint) indent irMap html comments =
+printElement (Subsoftconstraint s constraint) indent irMap html comments =
     preComments ++ 
     printIndent indent html ++ 
     printSoftConstraint constraint indent irMap html comments'' ++
@@ -193,38 +160,21 @@     (comments'', comment) = printComment s comments' 
 
 printElements :: Elements -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printElements ElementsEmpty _ _ _ _ = ""
-printElements (PosElementsEmpty _) indent irMap html comments = printElements ElementsEmpty indent irMap html comments
-printElements (ElementsList es) indent irMap html comments = "\n{" ++ mapElements es indent irMap html comments ++ "\n}"
+printElements (ElementsEmpty _) _ _ _ _ = ""
+printElements (ElementsList _ es) indent irMap html comments = "\n{" ++ mapElements es indent irMap html comments ++ "\n}"
     where mapElements []     _ _ _ _ = []
           mapElements (e':es') indent' irMap' html' comments' = if span' e' == noSpan
                                                           then (printElement e' (indent' + 1) irMap' html' comments' {-++ "\n"-}) ++ mapElements es' indent' irMap' html' comments'
                                                           else (printElement e' (indent' + 1) irMap' html' comments' {-++ "\n"-}) ++ mapElements es' indent' irMap' html' (afterSpan (span' e') comments')
           afterSpan s comments' = let (Span _ (Pos line _)) = s in dropWhile (\(x, _) -> let (Span _ (Pos line' _)) = x in line' <= line) comments'
-          span' (PosSubclafer s _) = s
-          span' (PosSubconstraint s _) = s
-          span' (PosClaferUse s _ _ _) = s
-          span' (PosSubgoal s _) = s
-          span' (PosSubsoftconstraint s _) = s
-          span' _ = noSpan
-printElements (PosElementsList _ es) indent irMap html comments = printElements (ElementsList es) indent irMap html comments
+          span' (Subclafer s _) = s
+          span' (Subconstraint s _) = s
+          span' (ClaferUse s _ _ _) = s
+          span' (Subgoal s _) = s
+          span' (Subsoftconstraint s _) = s
 
 printClafer :: Clafer -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printClafer (Clafer abstract gCard id' super' crd init' es) indent irMap html comments =
-  printIndentId indent html ++ 
-  claferDeclaration ++ 
-  printElements es indent irMap html comments ++
-  printIndentEnd html
-  where
-    claferDeclaration = concat [
-      printAbstract abstract html, 
-      printGCard gCard html,
-      printPosIdent id' Nothing html, 
-      printSuper super' indent irMap html comments, 
-      printCard crd, 
-      printInit init' indent irMap html comments]
-
-printClafer (PosClafer s abstract gCard id' super' crd init' es) indent irMap html comments =
+printClafer (Clafer s abstract gCard id' super' crd init' es) indent irMap html comments =
   preComments ++ 
   printIndentId indent html ++ 
   claferDeclaration ++ 
@@ -244,50 +194,36 @@       printInit init' indent irMap html comments]
 
 printGoal :: Goal -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String               
-printGoal (Goal exps') indent irMap html comments = 
+printGoal (Goal _ exps') indent irMap html comments = 
   (if html then "&lt;&lt;" else "<<") ++ 
   concatMap (\x -> printExp x indent irMap html comments) exps' ++ 
   if html then "&gt;&gt;" else ">>" 
-printGoal (PosGoal _ exps') indent irMap html comments = printGoal (Goal exps') indent irMap html comments
 
 printAbstract :: Abstract -> Bool -> String
-printAbstract Abstract html = (while html "<span class=\"keyword\">") ++ "abstract" ++ (while html "</span>") ++ " "
-printAbstract (PosAbstract _) html = printAbstract Abstract html
-printAbstract AbstractEmpty        _ = ""
-printAbstract (PosAbstractEmpty _) _ = ""
+printAbstract (Abstract _) html   = (while html "<span class=\"keyword\">") ++ "abstract" ++ (while html "</span>") ++ " "
+printAbstract (AbstractEmpty _) _ = ""
 
 printGCard :: GCard -> Bool -> String
 printGCard gCard html = case gCard of
-  (GCardInterval ncard) -> printNCard ncard
-  (PosGCardInterval _ ncard) -> printNCard ncard
-  GCardEmpty        -> ""
-  (PosGCardEmpty _) -> ""
-  GCardXor          -> (while html "<span class=\"keyword\">") ++ "xor" ++ (while html "</span>") ++ " "
-  (PosGCardXor _)   -> (while html "<span class=\"keyword\">") ++ "xor" ++ (while html "</span>") ++ " "
-  GCardOr           -> (while html "<span class=\"keyword\">") ++ "or"  ++ (while html "</span>") ++ " "
-  (PosGCardOr _)    -> (while html "<span class=\"keyword\">") ++ "or"  ++ (while html "</span>") ++ " "
-  GCardMux          -> (while html "<span class=\"keyword\">") ++ "mux" ++ (while html "</span>") ++ " "
-  (PosGCardMux _)   -> (while html "<span class=\"keyword\">") ++ "mux" ++ (while html "</span>") ++ " "
-  GCardOpt          -> (while html "<span class=\"keyword\">") ++ "opt" ++ (while html "</span>") ++ " "
-  (PosGCardOpt _)   -> (while html "<span class=\"keyword\">") ++ "opt" ++ (while html "</span>") ++ " "
+  (GCardInterval _ ncard) -> printNCard ncard
+  (GCardEmpty _)          -> ""
+  (GCardXor _)            -> (while html "<span class=\"keyword\">") ++ "xor" ++ (while html "</span>") ++ " "
+  (GCardOr _)             -> (while html "<span class=\"keyword\">") ++ "or"  ++ (while html "</span>") ++ " "
+  (GCardMux _)            -> (while html "<span class=\"keyword\">") ++ "mux" ++ (while html "</span>") ++ " "
+  (GCardOpt _)            -> (while html "<span class=\"keyword\">") ++ "opt" ++ (while html "</span>") ++ " "
 
 printNCard :: NCard -> String
-printNCard (NCard (PosInteger (_, num)) exInteger) = num ++ ".." ++ printExInteger exInteger ++ " "
-printNCard (PosNCard _ posinteger exinteger) = printNCard (NCard posinteger exinteger)
+printNCard (NCard _ (PosInteger (_, num)) exInteger) = num ++ ".." ++ printExInteger exInteger ++ " "
   
 printExInteger :: ExInteger -> String    
-printExInteger ExIntegerAst = "*"
-printExInteger (PosExIntegerAst _) = printExInteger ExIntegerAst
-printExInteger (ExIntegerNum (PosInteger(_, num))) = num
-printExInteger (PosExIntegerNum _ posInteger) = printExInteger (ExIntegerNum posInteger)
+printExInteger (ExIntegerAst _) = "*"
+printExInteger (ExIntegerNum _ (PosInteger(_, num))) = num
 
 printName :: Name -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printName (Path modids) indent irMap html comments = unwords $ map (\x -> printModId x indent irMap html comments) modids
-printName (PosPath _ modids) indent irMap html comments = printName (Path modids) indent irMap html comments
+printName (Path _ modids) indent irMap html comments = unwords $ map (\x -> printModId x indent irMap html comments) modids
 
 printModId :: ModId -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printModId (ModIdIdent posident) _ irMap html _ = printPosIdentRef posident irMap html
-printModId (PosModIdIdent _ posident) indent irMap html comments = printModId (ModIdIdent posident) indent irMap html comments
+printModId (ModIdIdent _ posident) _ irMap html _ = printPosIdentRef posident irMap html
 
 printPosIdent :: PosIdent -> Maybe String -> Bool -> String
 printPosIdent (PosIdent (_, id')) Nothing _ = id'
@@ -299,36 +235,25 @@       where uid' = getUid (PosIdent (p, id')) irMap
 
 printSuper :: Super -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printSuper SuperEmpty _ _ _ _ = ""
-printSuper (PosSuperEmpty _) indent irMap html comments = printSuper SuperEmpty indent irMap html comments
-printSuper (SuperSome superHow setExp) indent irMap html comments = printSuperHow superHow indent irMap html comments ++ printSetExp setExp indent irMap html comments
-printSuper (PosSuperSome _ superHow setExp) indent irMap html comments = printSuper (SuperSome superHow setExp) indent irMap html comments
+printSuper (SuperEmpty _) _ _ _ _ = ""
+printSuper (SuperSome _ superHow setExp) indent irMap html comments = printSuperHow superHow indent irMap html comments ++ printSetExp setExp indent irMap html comments
 
 printSuperHow :: SuperHow -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printSuperHow SuperColon  _ _ html _ = (while html "<span class=\"keyword\">") ++ " :" ++ (while html "</span>") ++ " "
-printSuperHow (PosSuperColon _) indent irMap html comments = printSuperHow SuperColon indent irMap html comments
-printSuperHow SuperArrow  _ _ html _ = (while html "<span class=\"keyword\">") ++ " ->" ++ (while html "</span>") ++ " "
-printSuperHow (PosSuperArrow _) indent irMap html comments = printSuperHow SuperArrow indent irMap html comments
-printSuperHow SuperMArrow _ _ html _ = (while html "<span class=\"keyword\">") ++ " ->>" ++ (while html "</span>") ++ " "
-printSuperHow (PosSuperMArrow _) indent irMap html comments = printSuperHow SuperMArrow indent irMap html comments
+printSuperHow (SuperColon _)  _ _ html _ = (while html "<span class=\"keyword\">") ++ " :" ++ (while html "</span>") ++ " "
+printSuperHow (SuperArrow _) _ _ html _ = (while html "<span class=\"keyword\">") ++ " ->" ++ (while html "</span>") ++ " "
+printSuperHow (SuperMArrow _) _ _ html _ = (while html "<span class=\"keyword\">") ++ " ->>" ++ (while html "</span>") ++ " "
 
 printCard :: Card -> String
-printCard CardEmpty = ""
-printCard (PosCardEmpty _) = printCard CardEmpty
-printCard CardLone = " ?"
-printCard (PosCardLone _) = printCard CardLone
-printCard CardSome = " +"
-printCard (PosCardSome _) = printCard CardSome
-printCard CardAny = " *"
-printCard (PosCardAny _) = printCard CardAny
-printCard (CardNum (PosInteger (_,num))) = " " ++ num 
-printCard (PosCardNum _ posInteger) = printCard (CardNum posInteger)
-printCard (CardInterval nCard) = " " ++ printNCard nCard
-printCard (PosCardInterval _ nCard) = printCard (CardInterval nCard)
+printCard (CardEmpty _) = ""
+printCard (CardLone _)  = " ?"
+printCard (CardSome _)  = " +"
+printCard (CardAny _)   = " *"
+printCard (CardNum _ (PosInteger (_,num))) = " " ++ num 
+printCard (CardInterval _ nCard) = " " ++ printNCard nCard
 
 printConstraint ::  Constraint -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printConstraint (Constraint exps') indent irMap html comments = (concatMap (\x -> printConstraint' x indent irMap html comments) exps')
-printConstraint (PosConstraint _ exps') indent irMap html comments = printConstraint (Constraint exps') indent irMap html comments
+printConstraint (Constraint _ exps') indent irMap html comments = (concatMap (\x -> printConstraint' x indent irMap html comments) exps')
+
 printConstraint' :: Exp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printConstraint' exp' indent irMap html comments = 
     while html "<span class=\"keyword\">" ++ "[" ++ while html "</span>" ++
@@ -338,8 +263,7 @@     while html "<span class=\"keyword\">" ++ "]" ++ while html "</span>"
 
 printSoftConstraint :: SoftConstraint -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printSoftConstraint (SoftConstraint exps') indent irMap html comments = concatMap (\x -> printSoftConstraint' x indent irMap html comments) exps'
-printSoftConstraint (PosSoftConstraint _ exps') indent irMap html comments = printSoftConstraint (SoftConstraint exps') indent irMap html comments
+printSoftConstraint (SoftConstraint _ exps') indent irMap html comments = concatMap (\x -> printSoftConstraint' x indent irMap html comments) exps'
 printSoftConstraint' :: Exp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
 printSoftConstraint' exp' indent' irMap html comments = 
     while html "<span class=\"keyword\">" ++ "(" ++ while html "</span>" ++ 
@@ -349,129 +273,78 @@     while html "<span class=\"keyword\">" ++ ")" ++ while html "</span>"
 
 printDecl :: Decl-> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printDecl (Decl locids setExp) indent irMap html comments = 
+printDecl (Decl _ locids setExp) indent irMap html comments = 
   (concat $ intersperse "; " $ map printLocId locids) ++
   (while html "<span class=\"keyword\">") ++ " : " ++ (while html "</span>") ++ printSetExp setExp indent irMap html comments
   where
     printLocId :: LocId -> String
-    printLocId (LocIdIdent (PosIdent (_, ident'))) = ident'
-    printLocId (PosLocIdIdent _ (PosIdent (_, ident'))) = ident'
-printDecl (PosDecl _ locids setExp) indent irMap html comments = printDecl (Decl locids setExp) indent irMap html comments
+    printLocId (LocIdIdent _ (PosIdent (_, ident'))) = ident'
 
 printInit :: Init -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printInit InitEmpty _ _ _ _ = ""
-printInit (PosInitEmpty _) indent irMap html comments = printInit InitEmpty indent irMap html comments
-printInit (InitSome initHow exp') indent irMap html comments = printInitHow initHow  ++ printExp exp' indent irMap html comments
-printInit (PosInitSome _ initHow exp') indent irMap html comments = printInit (InitSome initHow exp') indent irMap html comments
+printInit (InitEmpty _) _ _ _ _ = ""
+printInit (InitSome _ initHow exp') indent irMap html comments = printInitHow initHow  ++ printExp exp' indent irMap html comments
 
 printInitHow :: InitHow -> String
-printInitHow InitHow_1  = " = "
-printInitHow (PosInitHow_1 _)  = printInitHow InitHow_1
-printInitHow InitHow_2  = " := "
-printInitHow (PosInitHow_2 _)  = printInitHow InitHow_2
+printInitHow (InitHow_1 _) = " = "
+printInitHow (InitHow_2 _) = " := "
 
 printExp :: Exp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printExp (DeclAllDisj decl exp') indent irMap html comments = "all disj " ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (PosDeclAllDisj _ decl exp') indent irMap html comments = printExp (DeclAllDisj decl exp') indent irMap html comments
-printExp (DeclAll     decl exp') indent irMap html comments = "all " ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (PosDeclAll _ decl exp') indent irMap html comments = printExp (DeclAll decl exp') indent irMap html comments
-printExp (DeclQuantDisj quant' decl exp') indent irMap html comments = (printQuant quant' html) ++ "disj" ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (PosDeclQuantDisj _ quant' decl exp') indent irMap html comments = printExp (DeclQuantDisj quant' decl exp') indent irMap html comments
-printExp (DeclQuant     quant' decl exp') indent irMap html comments = (printQuant quant' html) ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
-printExp (PosDeclQuant _ quant' decl exp') indent irMap html comments = printExp (DeclQuant quant' decl exp') indent irMap html comments
-printExp (EGMax exp')            indent irMap html comments = "max " ++ printExp exp' indent irMap html comments
-printExp (PosEGMax _ exp')     indent irMap html comments = printExp (EGMax exp') indent irMap html comments
-printExp (EGMin exp')            indent irMap html comments = "min " ++ printExp exp' indent irMap html comments
-printExp (PosEGMin _ exp') indent irMap html comments = printExp (EGMin exp') indent irMap html comments
-printExp (ENeq exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " != " ++ (printExp exp'2 indent irMap html comments)
-printExp (PosENeq _ exp'1 exp'2) indent irMap html comments = printExp (ENeq exp'1 exp'2) indent irMap html comments
-printExp (ESetExp setExp)       indent irMap html comments = printSetExp setExp indent irMap html comments
-printExp (PosESetExp _ setExp) indent irMap html comments = printExp (ESetExp setExp) indent irMap html comments
-printExp (QuantExp quant' exp')   indent irMap html comments = printQuant quant' html ++ printExp exp' indent irMap html comments
-printExp (PosQuantExp _ quant' exp') indent irMap html comments = printExp (QuantExp quant' exp') indent irMap html comments
-printExp (EImplies exp'1 exp'2)   indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " => " ++ printExp exp'2 indent irMap html comments
-printExp (PosEImplies _ exp'1 exp'2) indent irMap html comments = printExp (EImplies exp'1 exp'2) indent irMap html comments
-printExp (EAnd exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " && " ++ printExp exp'2 indent irMap html comments
-printExp (PosEAnd _ exp'1 exp'2) indent irMap html comments = printExp (EAnd exp'1 exp'2) indent irMap html comments
-printExp (EOr exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " || " ++ printExp exp'2 indent irMap html comments
-printExp (PosEOr _ exp'1 exp'2) indent irMap html comments = printExp (EOr exp'1 exp'2) indent irMap html comments
-printExp (EXor exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " xor " ++ printExp exp'2 indent irMap html comments
-printExp (PosEXor _ exp'1 exp'2) indent irMap html comments = printExp (EXor exp'1 exp'2) indent irMap html comments
-printExp (ENeg exp')             indent irMap html comments = " ! " ++ printExp exp' indent irMap html comments
-printExp (PosENeg _ exp') indent irMap html comments = printExp (ENeg exp') indent irMap html comments
-printExp (ELt exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt; " else " < ") ++ printExp exp'2 indent irMap html comments
-printExp (PosELt _ exp'1 exp'2) indent irMap html comments = printExp (ELt exp'1 exp'2) indent irMap html comments
-printExp (EGt exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " > " ++ printExp exp'2 indent irMap html comments
-printExp (PosEGt _ exp'1 exp'2) indent irMap html comments = printExp (EGt exp'1 exp'2) indent irMap html comments
-printExp (EEq exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " = " ++ printExp exp'2 indent irMap html comments
-printExp (PosEEq _ exp'1 exp'2) indent irMap html comments = printExp (EEq exp'1 exp'2) indent irMap html comments
-printExp (ELte exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt;= " else " <= ") ++ printExp exp'2 indent irMap html comments
-printExp (PosELte _ exp'1 exp'2) indent irMap html comments = printExp (ELte exp'1 exp'2) indent irMap html comments
-printExp (EGte exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " >= " ++ printExp exp'2 indent irMap html comments
-printExp (PosEGte _ exp'1 exp'2) indent irMap html comments = printExp (EGte exp'1 exp'2) indent irMap html comments
-printExp (EIn exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " in " ++ printExp exp'2 indent irMap html comments
-printExp (PosEIn _ exp'1 exp'2) indent irMap html comments = printExp (EIn exp'1 exp'2) indent irMap html comments
-printExp (ENin exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " not in " ++ printExp exp'2 indent irMap html comments
-printExp (PosENin _ exp'1 exp'2) indent irMap html comments = printExp (ENin exp'1 exp'2) indent irMap html comments
-printExp (EIff exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt;=&gt; " else " <=> ") ++ printExp exp'2 indent irMap html comments
-printExp (PosEIff _ exp'1 exp'2) indent irMap html comments = printExp (EIff exp'1 exp'2) indent irMap html comments
-printExp (EAdd exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " + " ++ printExp exp'2 indent irMap html comments
-printExp (PosEAdd _ exp'1 exp'2) indent irMap html comments = printExp (EAdd exp'1 exp'2) indent irMap html comments
-printExp (ESub exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " - " ++ printExp exp'2 indent irMap html comments
-printExp (PosESub _ exp'1 exp'2) indent irMap html comments = printExp (ESub exp'1 exp'2) indent irMap html comments
-printExp (EMul exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " * " ++ printExp exp'2 indent irMap html comments
-printExp (PosEMul _ exp'1 exp'2) indent irMap html comments = printExp (EMul exp'1 exp'2) indent irMap html comments
-printExp (EDiv exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " / " ++ printExp exp'2 indent irMap html comments
-printExp (PosEDiv _ exp'1 exp'2) indent irMap html comments = printExp (EDiv exp'1 exp'2) indent irMap html comments
-printExp (ESumSetExp exp') indent irMap html comments = "sum " ++ printExp exp' indent irMap html comments
-printExp (PosESumSetExp _ exp') indent irMap html comments = printExp (ESumSetExp exp') indent irMap html comments
-printExp (ECSetExp exp')         indent irMap html comments = "# " ++ printExp exp' indent irMap html comments
-printExp (PosECSetExp _ exp') indent irMap html comments = printExp (ECSetExp exp') indent irMap html comments
-printExp (EMinExp exp')          indent irMap html comments = "-" ++ printExp exp' indent irMap html comments
-printExp (PosEMinExp _ exp') indent irMap html comments = printExp (EMinExp exp') indent irMap html comments
-printExp (EImpliesElse exp'1 exp'2 exp'3) indent irMap html comments = "if " ++ (printExp exp'1 indent irMap html comments) ++ " then " ++ (printExp exp'2 indent irMap html comments) ++ " else " ++ (printExp exp'3 indent irMap html comments)
-printExp (PosEImpliesElse _ exp'1 exp'2 exp'3) indent irMap html comments = printExp (EImpliesElse exp'1 exp'2 exp'3) indent irMap html comments
-printExp (EInt (PosInteger (_, num))) _ _ _ _ = num
-printExp (PosEInt _ posInteger) indent irMap html comments = printExp (EInt posInteger) indent irMap html comments
-printExp (EDouble (PosDouble (_, num))) _ _ _ _ = num
-printExp (PosEDouble _ posDouble) indent irMap html comments = printExp (EDouble posDouble) indent irMap html comments
-printExp (EStr (PosString (_, str))) _ _ _ _ = str
-printExp (PosEStr _ posString) indent irMap html comments = printExp (EStr posString) indent irMap html comments
+printExp (DeclAllDisj _ decl exp') indent irMap html comments = "all disj " ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
+printExp (DeclAll _     decl exp') indent irMap html comments = "all " ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
+printExp (DeclQuantDisj _ quant' decl exp') indent irMap html comments = (printQuant quant' html) ++ "disj" ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
+printExp (DeclQuant _     quant' decl exp') indent irMap html comments = (printQuant quant' html) ++ (printDecl decl indent irMap html comments) ++ " | " ++ (printExp exp' indent irMap html comments)
+printExp (EGMax _ exp')            indent irMap html comments = "max " ++ printExp exp' indent irMap html comments
+printExp (EGMin _ exp')            indent irMap html comments = "min " ++ printExp exp' indent irMap html comments
+printExp (ENeq _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " != " ++ (printExp exp'2 indent irMap html comments)
+printExp (ESetExp _ setExp)       indent irMap html comments = printSetExp setExp indent irMap html comments
+printExp (QuantExp _ quant' exp')   indent irMap html comments = printQuant quant' html ++ printExp exp' indent irMap html comments
+printExp (EImplies _ exp'1 exp'2)   indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " => " ++ printExp exp'2 indent irMap html comments
+printExp (EAnd _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " && " ++ printExp exp'2 indent irMap html comments
+printExp (EOr _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " || " ++ printExp exp'2 indent irMap html comments
+printExp (EXor _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " xor " ++ printExp exp'2 indent irMap html comments
+printExp (ENeg _ exp')             indent irMap html comments = " ! " ++ printExp exp' indent irMap html comments
+printExp (ELt _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt; " else " < ") ++ printExp exp'2 indent irMap html comments
+printExp (EGt _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " > " ++ printExp exp'2 indent irMap html comments
+printExp (EEq _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " = " ++ printExp exp'2 indent irMap html comments
+printExp (ELte _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt;= " else " <= ") ++ printExp exp'2 indent irMap html comments
+printExp (EGte _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " >= " ++ printExp exp'2 indent irMap html comments
+printExp (EIn _ exp'1 exp'2)        indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " in " ++ printExp exp'2 indent irMap html comments
+printExp (ENin _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " not in " ++ printExp exp'2 indent irMap html comments
+printExp (EIff _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ (if html then " &lt;=&gt; " else " <=> ") ++ printExp exp'2 indent irMap html comments
+printExp (EAdd _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " + " ++ printExp exp'2 indent irMap html comments
+printExp (ESub _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " - " ++ printExp exp'2 indent irMap html comments
+printExp (EMul _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " * " ++ printExp exp'2 indent irMap html comments
+printExp (EDiv _ exp'1 exp'2)       indent irMap html comments = (printExp exp'1 indent irMap html comments) ++ " / " ++ printExp exp'2 indent irMap html comments
+printExp (ESumSetExp _ exp') indent irMap html comments = "sum " ++ printExp exp' indent irMap html comments
+printExp (ECSetExp _ exp')         indent irMap html comments = "# " ++ printExp exp' indent irMap html comments
+printExp (EMinExp _ exp')          indent irMap html comments = "-" ++ printExp exp' indent irMap html comments
+printExp (EImpliesElse _ exp'1 exp'2 exp'3) indent irMap html comments = "if " ++ (printExp exp'1 indent irMap html comments) ++ " then " ++ (printExp exp'2 indent irMap html comments) ++ " else " ++ (printExp exp'3 indent irMap html comments)
+printExp (EInt _ (PosInteger (_, num))) _ _ _ _ = num
+printExp (EDouble _ (PosDouble (_, num))) _ _ _ _ = num
+printExp (EStr _ (PosString (_, str))) _ _ _ _ = str
 
 printSetExp :: SetExp -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printSetExp (ClaferId name) indent irMap html comments = printName name indent irMap html comments
-printSetExp (PosClaferId _ name) indent irMap html comments = printSetExp (ClaferId name) indent irMap html comments
-printSetExp (Union set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "++" ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosUnion _ set1 set2) indent irMap html comments = printSetExp (Union set1 set2) indent irMap html comments
-printSetExp (UnionCom set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ ", " ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosUnionCom _ set1 set2) indent irMap html comments = printSetExp (UnionCom set1 set2) indent irMap html comments
-printSetExp (Difference set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "--" ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosDifference _ set1 set2) indent irMap html comments = printSetExp (Difference set1 set2) indent irMap html comments
-printSetExp (Intersection set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "&" ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosIntersection _ set1 set2) indent irMap html comments = printSetExp (Intersection set1 set2) indent irMap html comments
-printSetExp (Domain set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "<:" ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosDomain _ set1 set2) indent irMap html comments = printSetExp (Domain set1 set2) indent irMap html comments
-printSetExp (Range set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ ":>" ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosRange _ set1 set2) indent irMap html comments = printSetExp (Range set1 set2) indent irMap html comments
-printSetExp (Join set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "." ++ (printSetExp set2 indent irMap html comments)
-printSetExp (PosJoin _ set1 set2) indent irMap html comments = printSetExp (Join set1 set2) indent irMap html comments
+printSetExp (ClaferId _ name) indent irMap html comments = printName name indent irMap html comments
+printSetExp (Union _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "++" ++ (printSetExp set2 indent irMap html comments)
+printSetExp (UnionCom _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ ", " ++ (printSetExp set2 indent irMap html comments)
+printSetExp (Difference _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "--" ++ (printSetExp set2 indent irMap html comments)
+printSetExp (Intersection _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "&" ++ (printSetExp set2 indent irMap html comments)
+printSetExp (Domain _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "<:" ++ (printSetExp set2 indent irMap html comments)
+printSetExp (Range _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ ":>" ++ (printSetExp set2 indent irMap html comments)
+printSetExp (Join _ set1 set2) indent irMap html comments = (printSetExp set1 indent irMap html comments) ++ "." ++ (printSetExp set2 indent irMap html comments)
 
 printQuant :: Quant -> Bool -> String
 printQuant quant' html = case quant' of
-  QuantNo        -> (while html "<span class=\"keyword\">") ++ "no" ++ (while html "</span>") ++ " "
-  PosQuantNo _   -> (while html "<span class=\"keyword\">") ++ "no" ++ (while html "</span>") ++ " "
-  QuantLone      -> (while html "<span class=\"keyword\">") ++ "lone" ++ (while html "</span>") ++ " "
-  PosQuantLone _ -> (while html "<span class=\"keyword\">") ++ "lone" ++ (while html "</span>") ++ " "
-  QuantOne       -> (while html "<span class=\"keyword\">") ++ "one" ++ (while html "</span>") ++ " "
-  PosQuantOne _  -> (while html "<span class=\"keyword\">") ++ "one" ++ (while html "</span>") ++ " "
-  QuantSome      -> (while html "<span class=\"keyword\">") ++ "some" ++ (while html "</span>") ++ " "
-  PosQuantSome _ -> (while html "<span class=\"keyword\">") ++ "some" ++ (while html "</span>") ++ " "
+  (QuantNo _)       -> (while html "<span class=\"keyword\">") ++ "no" ++ (while html "</span>") ++ " "
+  (QuantNot _)       -> (while html "<span class=\"keyword\">") ++ "not" ++ (while html "</span>") ++ " "
+  (QuantLone _)     -> (while html "<span class=\"keyword\">") ++ "lone" ++ (while html "</span>") ++ " "
+  (QuantOne _)      -> (while html "<span class=\"keyword\">") ++ "one" ++ (while html "</span>") ++ " "
+  (QuantSome _)     -> (while html "<span class=\"keyword\">") ++ "some" ++ (while html "</span>") ++ " "
 
 printEnumId :: EnumId -> Int -> Map.Map Span [Ir] -> Bool -> [(Span, String)] -> String
-printEnumId (EnumIdIdent posident) _ irMap html _ = printPosIdent posident (Just uid') html
+printEnumId (EnumIdIdent _ posident) _ irMap html _ = printPosIdent posident (Just uid') html
   where
     uid' = getUid posident irMap
-printEnumId (PosEnumIdIdent _ posident) indent irMap html comments = printEnumId (EnumIdIdent posident) indent irMap html comments
 
 printIndent :: Int -> Bool -> String
 printIndent 0 html = (while html "<div>") ++ "\n"
@@ -500,9 +373,9 @@ 
 getUid :: PosIdent -> Map.Map Span [Ir] -> String
 getUid posIdent@(PosIdent (_, id')) irMap = 
-    if Map.lookup (range posIdent) irMap == Nothing
+    if Map.lookup (getSpan posIdent) irMap == Nothing
     then "Lookup failed"
-    else let IRPExp pexp = head $ fromJust $ Map.lookup (range posIdent) irMap in
+    else let IRPExp pexp = head $ fromJust $ Map.lookup (getSpan posIdent) irMap in
       findUid id' $ getIdentPExp pexp
       where {getIdentPExp (PExp _ _ _ exp') = getIdentIExp exp';
              getIdentIExp (IFunExp _ exps') = concatMap getIdentPExp exps';
@@ -561,5 +434,4 @@   let (ls, lss) = genericSplitAt (l + toInteger n) model'
       newLine = fst (genericSplitAt (c - 1) $ last ls) ++ "<span class=\"error\" title=\"Compiling failed at line " ++ show l ++ " column " ++ show c ++
 				   "...\n" ++ msg' ++ "\">" ++ (if snd (genericSplitAt (c - 1) $ last ls) == "" then "&nbsp;" else snd (genericSplitAt (c - 1) $ last ls)) ++ "</span>"
-  in highlightErrors' (init ls ++ [newLine] ++ lss) es
-highlightErrors' _ _ = error "Function highlightErrors' from Html Generator did not expect a Parse/Sematic Err, given one." -- Should never happen+  in highlightErrors' (init ls ++ [newLine] ++ lss) es
src/Language/Clafer/Generator/Python.hs view
@@ -168,9 +168,6 @@ genPythonPosition :: Span -> String
 genPythonPosition (Span (Pos s1 s2) (Pos e1 e2)) = concat
   [ "pos=(", genPythonIntPair (s1, s2), ", ", genPythonIntPair (e1, e2), ")"]
-genPythonPosition (PosSpan _ s e) = genPythonPosition (Span s e)
-genPythonPosition (Span (PosPos _ s1 s2) e) = genPythonPosition (Span (Pos s1 s2) e)
-genPythonPosition (Span s (PosPos _ e1 e2)) = genPythonPosition (Span s (Pos e1 e2))
 
 genPythonIExpType :: IExp -> String
 genPythonIExpType x = case x of
src/Language/Clafer/Generator/Xml.hs view
@@ -139,9 +139,6 @@ genXmlPosition (Span (Pos s1 s2) (Pos e1 e2)) = concat
   [ tag "Start" $ genXmlIntPair (s1, s2)
   , tag "End"   $ genXmlIntPair (e1, e2)]
-genXmlPosition (PosSpan _ s e) = genXmlPosition (Span s e)
-genXmlPosition (Span (PosPos _ s1 s2) e) = genXmlPosition (Span (Pos s1 s2) e)
-genXmlPosition (Span s (PosPos _ e1 e2)) = genXmlPosition (Span s (Pos e1 e2))
 
 genXmlIExpType :: IExp -> String
 genXmlIExpType x = case x of
src/Language/Clafer/Intermediate/Analysis.hs view
@@ -47,7 +47,7 @@ 
 
 newtype AnalysisT m a = AnalysisT (ReaderT Info m a)
-  deriving (Monad, Functor, MonadReader Info, MonadState s, MonadTrans, MonadPlus, MonadError e, Applicative)
+  deriving (Monad, Functor, MonadReader Info, MonadState s, MonadTrans, MonadPlus, MonadError e, Applicative, Alternative)
   
 type Analysis = AnalysisT Identity
 
src/Language/Clafer/Intermediate/Desugarer.hs view
@@ -27,84 +27,71 @@ 
 import Language.Clafer.Common
 import Language.Clafer.Front.Absclafer
-import Language.Clafer.Front.Mapper
 import Language.Clafer.Intermediate.Intclafer
 
 -- | Transform the AST into the intermediate representation (IR)
 desugarModule :: Module -> IModule
-desugarModule (Module declarations) = desugarModule $ PosModule noSpan declarations
-desugarModule (PosModule _ declarations) = IModule "" $
+desugarModule (Module _ declarations) = IModule "" $
       declarations >>= desugarEnums >>= desugarDeclaration
 --      [ImoduleFragment $ declarations >>= desugarEnums >>= desugarDeclaration]
 
 sugarModule :: IModule -> Module
-sugarModule x = Module $ map sugarDeclaration $ _mDecls x -- (fragments x >>= mDecls)
+sugarModule x = Module noSpan $ map sugarDeclaration $ _mDecls x -- (fragments x >>= mDecls)
 
 -- | desugars enumeration to abstract and global singleton features
 desugarEnums :: Declaration -> [Declaration]
-desugarEnums (EnumDecl id' enumids) = desugarEnums $ PosEnumDecl noSpan id' enumids
-desugarEnums (PosEnumDecl _ id' enumids) = absEnum : map mkEnum enumids
+desugarEnums (EnumDecl s id' enumids) = (absEnum s) : map (mkEnum s) enumids
     where
-    oneToOne = (CardInterval $ NCard (PosInteger ((0,0), "1")) (ExIntegerNum $ PosInteger ((0,0), "1")))
-    absEnum = ElementDecl $ Subclafer $ Clafer
-              Abstract GCardEmpty id' SuperEmpty CardEmpty InitEmpty (ElementsList [])
-    mkEnum (PosEnumIdIdent _ eId) = ElementDecl $ Subclafer $ Clafer AbstractEmpty GCardEmpty
-                                  eId (SuperSome SuperColon (PosClaferId noSpan $ Path [ModIdIdent id'])) oneToOne InitEmpty (ElementsList [])
-    mkEnum (EnumIdIdent eId) = ElementDecl $ Subclafer $ Clafer AbstractEmpty GCardEmpty
-                                  eId (SuperSome SuperColon (PosClaferId noSpan $ Path [ModIdIdent id'])) oneToOne InitEmpty (ElementsList [])
+    oneToOne = (CardInterval noSpan $ NCard noSpan (PosInteger ((0,0), "1")) (ExIntegerNum noSpan $ PosInteger ((0,0), "1")))
+    absEnum s1 = ElementDecl s1 $ Subclafer s1 $ Clafer s1 (Abstract s1) (GCardEmpty s1) id' (SuperEmpty s1) (CardEmpty s1) (InitEmpty s1) (ElementsList s1 [])
+    mkEnum s2 (EnumIdIdent _ eId) = ElementDecl s2 $ 
+                                   Subclafer s2 $ 
+                                   Clafer s2 (AbstractEmpty s2) (GCardEmpty s2) eId ((SuperSome s2) (SuperColon s2) (ClaferId s2 $ Path s2 [ModIdIdent s2 id'])) oneToOne (InitEmpty s2) (ElementsList s2 [])
 desugarEnums x = [x]
 
 
 desugarDeclaration :: Declaration -> [IElement]
-desugarDeclaration (ElementDecl element) = desugarDeclaration $ PosElementDecl noSpan element
-desugarDeclaration (PosElementDecl _ element) = desugarElement element
+desugarDeclaration (ElementDecl _ element) = desugarElement element
 desugarDeclaration _ = error "desugared"
 
 
 sugarDeclaration :: IElement -> Declaration
-sugarDeclaration (IEClafer clafer) = ElementDecl $ Subclafer $ sugarClafer clafer
+sugarDeclaration (IEClafer clafer) = ElementDecl (_cinPos clafer) $ Subclafer (_cinPos clafer) $ sugarClafer clafer
 sugarDeclaration (IEConstraint True constraint) =
-      ElementDecl $ Subconstraint $ sugarConstraint constraint
+      ElementDecl (_inPos constraint) $ Subconstraint (_inPos constraint) $ sugarConstraint constraint
 sugarDeclaration  (IEConstraint False softconstraint) =
-      ElementDecl $ Subsoftconstraint $ sugarSoftConstraint softconstraint
-sugarDeclaration  (IEGoal _ goal) = ElementDecl $ Subgoal $ sugarGoal goal
+      ElementDecl (_inPos softconstraint) $ Subsoftconstraint (_inPos softconstraint) $ sugarSoftConstraint softconstraint
+sugarDeclaration  (IEGoal _ goal) = ElementDecl (_inPos goal) $ Subgoal (_inPos goal) $ sugarGoal goal
 
 
 desugarClafer :: Clafer -> [IElement]
-desugarClafer (Clafer abstract gcrd id' super' crd init' es)  = 
-    desugarClafer $ PosClafer noSpan abstract gcrd id' super' crd init' es
-desugarClafer (PosClafer s abstract gcrd id' super' crd init' es)  = 
+desugarClafer (Clafer s abstract gcrd id' super' crd init' es)  = 
     (IEClafer $ IClafer s (desugarAbstract abstract) (desugarGCard gcrd) (transIdent id')
             "" (desugarSuper super') (desugarCard crd) (0, -1)
             (desugarElements es)) : (desugarInit id' init')
 
 
 sugarClafer :: IClafer -> Clafer
-sugarClafer (IClafer _ abstract gcard' _ uid' super' crd _ es) = 
-    Clafer (sugarAbstract abstract) (sugarGCard gcard') (mkIdent uid')
-      (sugarSuper super') (sugarCard crd) InitEmpty (sugarElements es)
+sugarClafer (IClafer s abstract gcard' _ uid' super' crd _ es) = 
+    Clafer s (sugarAbstract abstract) (sugarGCard gcard') (mkIdent uid')
+      (sugarSuper super') (sugarCard crd) (InitEmpty s) (sugarElements es)
 
 
 desugarSuper :: Super -> ISuper
-desugarSuper SuperEmpty = desugarSuper $ PosSuperEmpty noSpan
-desugarSuper (SuperSome superhow setexp) = desugarSuper $ PosSuperSome noSpan superhow setexp
-desugarSuper (PosSuperEmpty s) =
+desugarSuper (SuperEmpty s) =
       ISuper False [PExp (Just $ TClafer []) "" s $ mkLClaferId baseClafer True]
-desugarSuper (PosSuperSome _ superhow setexp) =
+desugarSuper (SuperSome _ superhow setexp) =
       ISuper (desugarSuperHow superhow) [desugarSetExp setexp]
 
 
 desugarSuperHow :: SuperHow -> Bool
-desugarSuperHow SuperColon = desugarSuperHow $ PosSuperColon noSpan
-desugarSuperHow (PosSuperColon _) = False
+desugarSuperHow (SuperColon _) = False
 desugarSuperHow _  = True
 
 
 desugarInit :: PosIdent -> Init -> [IElement]
-desugarInit id' InitEmpty = desugarInit id' $ PosInitEmpty noSpan
-desugarInit id' (InitSome inithow exp') = desugarInit id' $ PosInitSome noSpan inithow exp'
-desugarInit _ (PosInitEmpty _) = []
-desugarInit id' (PosInitSome s inithow exp') = [ IEConstraint (desugarInitHow inithow) (pExpDefPid s implIExp) ]
+desugarInit _ (InitEmpty _) = []
+desugarInit id' (InitSome s inithow exp') = [ IEConstraint (desugarInitHow inithow) (pExpDefPid s implIExp) ]
   where 
     cId :: PExp
     cId = mkPLClaferId (snd $ getIdent id') False
@@ -117,280 +104,207 @@     getIdent (PosIdent y) = y
 
 desugarInitHow :: InitHow -> Bool
-desugarInitHow InitHow_1  = desugarInitHow $ PosInitHow_1 noSpan
-desugarInitHow InitHow_2  = desugarInitHow $ PosInitHow_2 noSpan
-desugarInitHow (PosInitHow_1 _) = True
-desugarInitHow (PosInitHow_2 _ )= False
+desugarInitHow (InitHow_1 _) = True
+desugarInitHow (InitHow_2 _ )= False
 
 
 desugarName :: Name -> IExp
-desugarName (Path path) = desugarName $ PosPath noSpan path
-desugarName (PosPath _ path) =
+desugarName (Path _ path) =
       IClaferId (concatMap ((++ modSep).desugarModId) (init path))
                 (desugarModId $ last path) True
 
 desugarModId :: ModId -> Result
-desugarModId (ModIdIdent id') = desugarModId $ PosModIdIdent noSpan id'
-desugarModId (PosModIdIdent _ id') = transIdent id'
+desugarModId (ModIdIdent _ id') = transIdent id'
 
 sugarModId :: String -> ModId
-sugarModId modid = ModIdIdent $ mkIdent modid
+sugarModId modid = ModIdIdent noSpan $ mkIdent modid
 
 sugarSuper :: ISuper -> Super
-sugarSuper (ISuper _ []) = SuperEmpty
-sugarSuper (ISuper isOverlapping' [pexp]) = SuperSome (sugarSuperHow isOverlapping') (sugarSetExp pexp)
+sugarSuper (ISuper _ []) = SuperEmpty noSpan
+sugarSuper (ISuper isOverlapping' [pexp]) = SuperSome noSpan (sugarSuperHow isOverlapping') (sugarSetExp pexp)
 sugarSuper _ = error "Function sugarSuper from Desugarer expects an ISuper with a list of length one, but it was given one with a list larger than one" -- Should never happen
 
 sugarSuperHow :: Bool -> SuperHow
-sugarSuperHow False = SuperColon
-sugarSuperHow True  = SuperMArrow
+sugarSuperHow False = SuperColon noSpan
+sugarSuperHow True  = SuperMArrow noSpan
 
 
 sugarInitHow :: Bool -> InitHow
-sugarInitHow True  = InitHow_1
-sugarInitHow False = InitHow_2
+sugarInitHow True  = InitHow_1 noSpan
+sugarInitHow False = InitHow_2 noSpan
 
 
 desugarConstraint :: Constraint -> PExp
-desugarConstraint (Constraint exps') = desugarConstraint $ PosConstraint noSpan exps'
-desugarConstraint (PosConstraint _ exps') = desugarPath $ desugarExp $
-    (if length exps' > 1 then foldl1 (PosEAnd noSpan) else head) exps'
+desugarConstraint (Constraint _ exps') = desugarPath $ desugarExp $
+    (if length exps' > 1 then foldl1 (EAnd noSpan) else head) exps'
 
 desugarSoftConstraint :: SoftConstraint -> PExp
-desugarSoftConstraint (SoftConstraint exps') = desugarSoftConstraint $ PosSoftConstraint noSpan exps'
-desugarSoftConstraint (PosSoftConstraint _ exps') = desugarPath $ desugarExp $
-    (if length exps' > 1 then foldl1 (PosEAnd noSpan) else head) exps'
+desugarSoftConstraint (SoftConstraint _ exps') = desugarPath $ desugarExp $
+    (if length exps' > 1 then foldl1 (EAnd noSpan) else head) exps'
 
 desugarGoal :: Goal -> PExp
-desugarGoal (Goal exps') = desugarGoal $ PosGoal noSpan exps'
-desugarGoal (PosGoal _ exps') = desugarPath $ desugarExp $
-    (if length exps' > 1 then foldl1 (PosEAnd noSpan) else head) exps'
+desugarGoal (Goal s exps') = desugarPath $ desugarExp $
+    (if length exps' > 1 then foldl1 (EAnd s) else head) exps'
 
 sugarConstraint :: PExp -> Constraint
-sugarConstraint pexp = Constraint $ map sugarExp [pexp]
+sugarConstraint pexp = Constraint (_inPos pexp)  $ map sugarExp [pexp]
 
 sugarSoftConstraint :: PExp -> SoftConstraint
-sugarSoftConstraint pexp = SoftConstraint $ map sugarExp [pexp]
+sugarSoftConstraint pexp = SoftConstraint (_inPos pexp) $ map sugarExp [pexp]
 
 sugarGoal :: PExp -> Goal
-sugarGoal pexp = Goal $ map sugarExp [pexp]
+sugarGoal pexp = Goal (_inPos pexp) $ map sugarExp [pexp]
 
 desugarAbstract :: Abstract -> Bool
-desugarAbstract AbstractEmpty = desugarAbstract $ PosAbstractEmpty noSpan
-desugarAbstract Abstract = desugarAbstract $ PosAbstract noSpan
-desugarAbstract (PosAbstractEmpty _) = False
-desugarAbstract (PosAbstract _) = True
+desugarAbstract (AbstractEmpty _) = False
+desugarAbstract (Abstract _) = True
 
 
 sugarAbstract :: Bool -> Abstract
-sugarAbstract False = AbstractEmpty
-sugarAbstract True = Abstract
+sugarAbstract False = AbstractEmpty noSpan
+sugarAbstract True = Abstract noSpan
 
 
 desugarElements :: Elements -> [IElement]
-desugarElements (ElementsEmpty) = desugarElements $ PosElementsEmpty noSpan
-desugarElements (ElementsList es)  = desugarElements $ PosElementsList noSpan es
-desugarElements (PosElementsEmpty _) = []
-desugarElements (PosElementsList _ es)  = es >>= desugarElement
+desugarElements (ElementsEmpty _) = []
+desugarElements (ElementsList _ es)  = es >>= desugarElement
 
 
 sugarElements :: [IElement] -> Elements
-sugarElements x = ElementsList $ map sugarElement x
+sugarElements x = ElementsList noSpan $ map sugarElement x
 
 
 desugarElement :: Element -> [IElement]
 desugarElement x = case x of
-  Subclafer claf  -> desugarElement $ PosSubclafer noSpan claf
-  ClaferUse name crd es  ->
-      desugarElement $ PosClaferUse noSpan name crd es
-  Subconstraint constraint  -> desugarElement $ PosSubconstraint noSpan constraint
-  Subsoftconstraint softconstraint ->
-      desugarElement $ PosSubsoftconstraint noSpan softconstraint
-  Subgoal goal -> desugarElement $ PosSubgoal noSpan goal
-  PosSubclafer _ claf  ->
+  Subclafer _ claf  ->
       (desugarClafer claf) ++
       (mkArrowConstraint claf >>= desugarElement)
-  PosClaferUse s name crd es  -> desugarClafer $ PosClafer s
-      AbstractEmpty GCardEmpty (mkIdent $ _sident $ desugarName name)
-      (SuperSome SuperColon (PosClaferId noSpan name)) crd InitEmpty es
-  PosSubconstraint _ constraint  ->
+  ClaferUse s name crd es  -> desugarClafer $ Clafer s
+      (AbstractEmpty s) (GCardEmpty s) (mkIdent $ _sident $ desugarName name)
+      ((SuperSome s) (SuperColon s) (ClaferId s name)) crd (InitEmpty s) es
+  Subconstraint _ constraint  ->
       [IEConstraint True $ desugarConstraint constraint]
-  PosSubsoftconstraint _ softconstraint ->
+  Subsoftconstraint _ softconstraint ->
       [IEConstraint False $ desugarSoftConstraint softconstraint]
-  PosSubgoal _ goal -> [IEGoal True $ desugarGoal goal]
+  Subgoal _ goal -> [IEGoal True $ desugarGoal goal]
 
 sugarElement :: IElement -> Element
 sugarElement x = case x of
-  IEClafer claf  -> Subclafer $ sugarClafer claf
-  IEConstraint True constraint -> Subconstraint $ sugarConstraint constraint
-  IEConstraint False softconstraint -> Subsoftconstraint $ sugarSoftConstraint softconstraint
-  IEGoal _ goal -> Subgoal $ sugarGoal goal
+  IEClafer claf  -> Subclafer noSpan $ sugarClafer claf
+  IEConstraint True constraint -> Subconstraint noSpan $ sugarConstraint constraint
+  IEConstraint False softconstraint -> Subsoftconstraint noSpan $ sugarSoftConstraint softconstraint
+  IEGoal _ goal -> Subgoal noSpan $ sugarGoal goal
 
 mkArrowConstraint :: Clafer -> [Element]
-mkArrowConstraint (Clafer abstract gcard' id' super' crd init' es) =
-    mkArrowConstraint $ PosClafer noSpan abstract gcard' id' super' crd init' es
-mkArrowConstraint (PosClafer _ _ _ ident' super' _ _ _) = 
-  if isSuperSomeArrow super' then  [Subconstraint $
-       Constraint [PosDeclAllDisj noSpan
-       (Decl [LocIdIdent $ mkIdent "x", LocIdIdent $ mkIdent "y"]
-             (PosClaferId noSpan  $ Path [ModIdIdent ident']))
-       (PosENeq noSpan (PosESetExp noSpan $ Join (PosClaferId noSpan $ Path [ModIdIdent $ mkIdent "x"])
-                             (PosClaferId noSpan $ Path [ModIdIdent $ mkIdent "ref"]))
-             (PosESetExp noSpan $ Join (PosClaferId noSpan $ Path [ModIdIdent $ mkIdent "y"])
-                             (PosClaferId noSpan $ Path [ModIdIdent $ mkIdent "ref"])))]]
+mkArrowConstraint (Clafer s _ _ ident' super' _ _ _) = 
+  if isSuperSomeArrow super' then  [Subconstraint s $
+       Constraint s [DeclAllDisj s
+       (Decl s [LocIdIdent s $ mkIdent "x", LocIdIdent s $ mkIdent "y"]
+             (ClaferId s $ Path s [ModIdIdent s ident']))
+       (ENeq s (ESetExp s $ Join s (ClaferId s $ Path s [ModIdIdent s $ mkIdent "x"])
+                             (ClaferId s $ Path s [ModIdIdent s $ mkIdent "ref"]))
+             (ESetExp s $ Join s (ClaferId s $ Path s [ModIdIdent s $ mkIdent "y"])
+                             (ClaferId s $ Path s [ModIdIdent s $ mkIdent "ref"])))]]
   else []
 
 isSuperSomeArrow :: Super -> Bool
-isSuperSomeArrow (SuperSome arrow _) = isSuperArrow arrow
-isSuperSomeArrow (PosSuperSome _ arrow _) = isSuperArrow arrow
+isSuperSomeArrow (SuperSome _ arrow _) = isSuperArrow arrow
 isSuperSomeArrow _ = False
 
 isSuperArrow :: SuperHow -> Bool
-isSuperArrow SuperArrow = True
-isSuperArrow (PosSuperArrow _) = True
+isSuperArrow (SuperArrow _) = True
 isSuperArrow _ = False
 
 desugarGCard :: GCard -> Maybe IGCard
 desugarGCard x = case x of
-  GCardEmpty  -> desugarGCard $ PosGCardEmpty noSpan
-  GCardXor -> desugarGCard $ PosGCardXor noSpan
-  GCardOr  -> desugarGCard $ PosGCardOr noSpan
-  GCardMux -> desugarGCard $ PosGCardMux noSpan
-  GCardOpt -> desugarGCard $ PosGCardOpt noSpan
-  GCardInterval crd -> desugarGCard $ PosGCardInterval noSpan crd
-  PosGCardEmpty _  -> Nothing
-  PosGCardXor _ -> Just $ IGCard True (1, 1)
-  PosGCardOr _  -> Just $ IGCard True (1, -1)
-  PosGCardMux _ -> Just $ IGCard True (0, 1)
-  PosGCardOpt _ -> Just $ IGCard True (0, -1)
-  PosGCardInterval _ ncard ->
+  GCardEmpty _  -> Nothing
+  GCardXor _ -> Just $ IGCard True (1, 1)
+  GCardOr _  -> Just $ IGCard True (1, -1)
+  GCardMux _ -> Just $ IGCard True (0, 1)
+  GCardOpt _ -> Just $ IGCard True (0, -1)
+  GCardInterval _ ncard ->
       Just $ IGCard (isOptionalDef ncard) $ desugarNCard ncard
 
 isOptionalDef :: NCard -> Bool
-isOptionalDef (PosNCard _ m n) = isOptionalDef $ NCard m n
-isOptionalDef (NCard m n) = ((0::Integer) == mkInteger m) && (not $ isExIntegerAst n)
+isOptionalDef (NCard _ m n) = ((0::Integer) == mkInteger m) && (not $ isExIntegerAst n)
 
 isExIntegerAst :: ExInteger -> Bool
-isExIntegerAst ExIntegerAst = True
-isExIntegerAst (PosExIntegerAst _) = True
+isExIntegerAst (ExIntegerAst _) = True
 isExIntegerAst _ = False
 
 sugarGCard :: Maybe IGCard -> GCard
 sugarGCard x = case x of
-  Nothing -> GCardEmpty
-  Just (IGCard _ (i, ex)) -> GCardInterval $ NCard (PosInteger ((0, 0), show i)) (sugarExInteger ex)
+  Nothing -> GCardEmpty noSpan
+  Just (IGCard _ (i, ex)) -> GCardInterval noSpan $ NCard noSpan (PosInteger ((0, 0), show i)) (sugarExInteger ex)
 
 
 desugarCard :: Card -> Maybe Interval
 desugarCard x = case x of
-  CardEmpty  -> desugarCard $ PosCardEmpty noSpan
-  CardLone  ->  desugarCard $ PosCardLone noSpan
-  CardSome  ->  desugarCard $ PosCardSome noSpan
-  CardAny  -> desugarCard $ PosCardAny noSpan
-  CardNum n  -> desugarCard $ PosCardNum noSpan n
-  CardInterval crd  -> desugarCard $ PosCardInterval noSpan crd
-  PosCardEmpty _  -> Nothing
-  PosCardLone _  ->  Just (0, 1)
-  PosCardSome _  ->  Just (1, -1)
-  PosCardAny _ ->  Just (0, -1)
-  PosCardNum _ n  -> Just (mkInteger n, mkInteger n)
-  PosCardInterval _ ncard  -> Just $ desugarNCard ncard
+  CardEmpty _  -> Nothing
+  CardLone _  ->  Just (0, 1)
+  CardSome _  ->  Just (1, -1)
+  CardAny _ ->  Just (0, -1)
+  CardNum _ n  -> Just (mkInteger n, mkInteger n)
+  CardInterval _ ncard  -> Just $ desugarNCard ncard
 
 desugarNCard :: NCard -> (Integer, Integer)
-desugarNCard (NCard i ex) = desugarNCard $ PosNCard noSpan i ex
-desugarNCard (PosNCard _ i ex) = (mkInteger i, desugarExInteger ex)
+desugarNCard (NCard _ i ex) = (mkInteger i, desugarExInteger ex)
 
 desugarExInteger :: ExInteger -> Integer
-desugarExInteger ExIntegerAst = -1
-desugarExInteger (PosExIntegerAst _) = -1
-desugarExInteger (ExIntegerNum n) = mkInteger n
-desugarExInteger (PosExIntegerNum _ n) = mkInteger n
+desugarExInteger (ExIntegerAst _) = -1
+desugarExInteger (ExIntegerNum _ n) = mkInteger n
 
 sugarCard :: Maybe Interval -> Card
 sugarCard x = case x of
-  Nothing -> CardEmpty
+  Nothing -> CardEmpty noSpan
   Just (i, ex) ->
-      CardInterval $ NCard (PosInteger ((0, 0), show i)) (sugarExInteger ex)
+      CardInterval noSpan $ NCard noSpan (PosInteger ((0, 0), show i)) (sugarExInteger ex)
 
 sugarExInteger :: Integer -> ExInteger
-sugarExInteger n = if n == -1 then ExIntegerAst else (ExIntegerNum $ PosInteger ((0, 0), show n))
+sugarExInteger n = if n == -1 then ExIntegerAst noSpan else (ExIntegerNum noSpan $ PosInteger ((0, 0), show n))
 
 desugarExp :: Exp -> PExp
-desugarExp x = pExpDefPid (range x) $ desugarExp' x
+desugarExp x = pExpDefPid (getSpan x) $ desugarExp' x
 
 desugarExp' :: Exp -> IExp
 desugarExp' x = case x of
-  DeclAllDisj decl exp' -> desugarExp' $ PosDeclAllDisj noSpan decl exp'
-  DeclAll decl exp' -> desugarExp' $ PosDeclAll noSpan decl exp'
-  DeclQuantDisj quant' decl exp' ->
-      desugarExp' $ PosDeclQuantDisj noSpan quant' decl exp'
-  DeclQuant quant' decl exp' -> desugarExp' $ PosDeclQuant noSpan quant' decl exp'
-  EIff exp0 exp'  -> desugarExp' $ PosEIff noSpan exp0 exp'
-  EImplies exp0 exp'  -> desugarExp' $ PosEImplies noSpan exp0 exp'
-  EImpliesElse exp0 exp1 exp'  -> desugarExp' $ PosEImpliesElse noSpan exp0 exp1 exp'
-  EOr exp0 exp'  -> desugarExp' $ PosEOr noSpan exp0 exp'
-  EXor exp0 exp'  -> desugarExp' $ PosEXor noSpan exp0 exp'
-  EAnd exp0 exp'  -> desugarExp' $ PosEAnd noSpan exp0 exp'
-  ENeg exp' -> desugarExp' $ PosENeg noSpan exp'
-  QuantExp quant' exp'  -> desugarExp' $ PosQuantExp noSpan quant' exp'
-  ELt  exp0 exp'  -> desugarExp' $ PosELt noSpan exp0 exp'
-  EGt  exp0 exp'  -> desugarExp' $ PosEGt noSpan exp0 exp'
-  EEq  exp0 exp'  -> desugarExp' $ PosEEq noSpan exp0 exp'
-  ELte exp0 exp'  -> desugarExp' $ PosELte noSpan exp0 exp'
-  EGte exp0 exp'  -> desugarExp' $ PosEGte noSpan exp0 exp'
-  ENeq exp0 exp'  -> desugarExp' $ PosENeq noSpan exp0 exp'
-  EIn  exp0 exp'  -> desugarExp' $ PosEIn noSpan exp0 exp'
-  ENin exp0 exp'  -> desugarExp' $ PosENin noSpan exp0 exp'
-  EAdd exp0 exp'  -> desugarExp' $ PosEAdd noSpan exp0 exp'
-  ESub exp0 exp'  -> desugarExp' $ PosESub noSpan exp0 exp'
-  EMul exp0 exp'  -> desugarExp' $ PosEMul noSpan exp0 exp'
-  EDiv exp0 exp'  -> desugarExp' $ PosEDiv noSpan exp0 exp'
-  ECSetExp exp'   -> desugarExp' $ PosECSetExp noSpan exp'
-  ESumSetExp sexp -> desugarExp' $ PosESumSetExp noSpan sexp  
-  EMinExp exp'    -> desugarExp' $ PosEMinExp noSpan exp'
-  EGMax exp' -> desugarExp' $ PosEGMax noSpan exp'
-  EGMin exp' -> desugarExp' $ PosEGMin noSpan exp'
-  EInt n -> desugarExp' $ PosEInt noSpan n
-  EDouble n -> desugarExp' $ PosEDouble noSpan n
-  EStr str  -> desugarExp' $ PosEStr noSpan str
-  ESetExp sexp -> desugarExp' $ PosESetExp noSpan sexp    
-  PosDeclAllDisj _ decl exp' ->
+  DeclAllDisj _ decl exp' ->
       IDeclPExp IAll [desugarDecl True decl] (dpe exp')
-  PosDeclAll _ decl exp' -> IDeclPExp IAll [desugarDecl False decl] (dpe exp')
-  PosDeclQuantDisj _ quant' decl exp' ->
+  DeclAll _ decl exp' -> IDeclPExp IAll [desugarDecl False decl] (dpe exp')
+  DeclQuantDisj _ quant' decl exp' ->
       IDeclPExp (desugarQuant quant') [desugarDecl True decl] (dpe exp')
-  PosDeclQuant _ quant' decl exp' ->
+  DeclQuant _ quant' decl exp' ->
       IDeclPExp (desugarQuant quant') [desugarDecl False decl] (dpe exp')
-  PosEIff _ exp0 exp'  -> dop iIff [exp0, exp']
-  PosEImplies _ exp0 exp'  -> dop iImpl [exp0, exp']
-  PosEImpliesElse _ exp0 exp1 exp'  -> dop iIfThenElse [exp0, exp1, exp']
-  PosEOr _ exp0 exp'  -> dop iOr   [exp0, exp']
-  PosEXor _ exp0 exp'  -> dop iXor [exp0, exp']
-  PosEAnd _ exp0 exp'  -> dop iAnd [exp0, exp']
-  PosENeg _ exp'  -> dop iNot [exp']
-  PosQuantExp _ quant' exp' ->
+  EIff _ exp0 exp'  -> dop iIff [exp0, exp']
+  EImplies _ exp0 exp'  -> dop iImpl [exp0, exp']
+  EImpliesElse _ exp0 exp1 exp'  -> dop iIfThenElse [exp0, exp1, exp']
+  EOr _ exp0 exp'  -> dop iOr   [exp0, exp']
+  EXor _ exp0 exp'  -> dop iXor [exp0, exp']
+  EAnd _ exp0 exp'  -> dop iAnd [exp0, exp']
+  ENeg _ exp'  -> dop iNot [exp']
+  QuantExp _ quant' exp' ->
       IDeclPExp (desugarQuant quant') [] (desugarExp exp')
-  PosELt  _ exp0 exp'  -> dop iLt  [exp0, exp']
-  PosEGt  _ exp0 exp'  -> dop iGt  [exp0, exp']
-  PosEEq  _ exp0 exp'  -> dop iEq  [exp0, exp']
-  PosELte _ exp0 exp'  -> dop iLte [exp0, exp']
-  PosEGte _ exp0 exp'  -> dop iGte [exp0, exp']
-  PosENeq _ exp0 exp'  -> dop iNeq [exp0, exp']
-  PosEIn  _ exp0 exp'  -> dop iIn  [exp0, exp']
-  PosENin _ exp0 exp'  -> dop iNin [exp0, exp']
-  PosEAdd _ exp0 exp'  -> dop iPlus [exp0, exp']
-  PosESub _ exp0 exp'  -> dop iSub [exp0, exp']
-  PosEMul _ exp0 exp'  -> dop iMul [exp0, exp']
-  PosEDiv _ exp0 exp'  -> dop iDiv [exp0, exp']
-  PosECSetExp _ exp'   -> dop iCSet [exp']
-  PosESumSetExp _ exp' -> dop iSumSet [exp']
-  PosEMinExp _ exp'    -> dop iMin [exp']  
-  PosEGMax _ exp' -> dop iGMax [exp']
-  PosEGMin _ exp' -> dop iGMin [exp']  
-  PosEInt _ n  -> IInt $ mkInteger n
-  PosEDouble _ (PosDouble n) -> IDouble $ read $ snd n
-  PosEStr _ (PosString str)  -> IStr $ snd str
-  PosESetExp _ sexp -> desugarSetExp' sexp
+  ELt  _ exp0 exp'  -> dop iLt  [exp0, exp']
+  EGt  _ exp0 exp'  -> dop iGt  [exp0, exp']
+  EEq  _ exp0 exp'  -> dop iEq  [exp0, exp']
+  ELte _ exp0 exp'  -> dop iLte [exp0, exp']
+  EGte _ exp0 exp'  -> dop iGte [exp0, exp']
+  ENeq _ exp0 exp'  -> dop iNeq [exp0, exp']
+  EIn  _ exp0 exp'  -> dop iIn  [exp0, exp']
+  ENin _ exp0 exp'  -> dop iNin [exp0, exp']
+  EAdd _ exp0 exp'  -> dop iPlus [exp0, exp']
+  ESub _ exp0 exp'  -> dop iSub [exp0, exp']
+  EMul _ exp0 exp'  -> dop iMul [exp0, exp']
+  EDiv _ exp0 exp'  -> dop iDiv [exp0, exp']
+  ECSetExp _ exp'   -> dop iCSet [exp']
+  ESumSetExp _ exp' -> dop iSumSet [exp']
+  EMinExp _ exp'    -> dop iMin [exp']  
+  EGMax _ exp' -> dop iGMax [exp']
+  EGMin _ exp' -> dop iGMin [exp']  
+  EInt _ n  -> IInt $ mkInteger n
+  EDouble _ (PosDouble n) -> IDouble $ read $ snd n
+  EStr _ (PosString str)  -> IStr $ snd str
+  ESetExp _ sexp -> desugarSetExp' sexp
   where
   dop = desugarOp desugarExp
   dpe = desugarPath.desugarExp
@@ -407,27 +321,19 @@ 
 
 desugarSetExp :: SetExp -> PExp
-desugarSetExp x = pExpDefPid (range x) $ desugarSetExp' x
+desugarSetExp x = pExpDefPid (getSpan x) $ desugarSetExp' x
 
 
 desugarSetExp' :: SetExp -> IExp
 desugarSetExp' x = case x of
-  Union exp0 exp'        -> desugarSetExp' $ PosUnion noSpan exp0 exp'
-  UnionCom exp0 exp'     -> desugarSetExp' $ PosUnionCom noSpan exp0 exp'
-  Difference exp0 exp'   -> desugarSetExp' $ PosDifference noSpan exp0 exp'
-  Intersection exp0 exp' -> desugarSetExp' $ PosIntersection noSpan exp0 exp'
-  Domain exp0 exp'       -> desugarSetExp' $ PosDomain noSpan exp0 exp'
-  Range exp0 exp'        -> desugarSetExp' $ PosRange noSpan exp0 exp'
-  Join exp0 exp'         -> desugarSetExp' $ PosJoin noSpan exp0 exp'
-  ClaferId name  -> desugarSetExp' $ PosClaferId noSpan name
-  PosUnion _ exp0 exp'        -> dop iUnion        [exp0, exp']
-  PosUnionCom _ exp0 exp'     -> dop iUnion        [exp0, exp']
-  PosDifference _ exp0 exp'   -> dop iDifference   [exp0, exp']
-  PosIntersection _ exp0 exp' -> dop iIntersection [exp0, exp']
-  PosDomain _ exp0 exp'       -> dop iDomain       [exp0, exp']
-  PosRange _ exp0 exp'        -> dop iRange        [exp0, exp']
-  PosJoin _ exp0 exp'         -> dop iJoin         [exp0, exp']
-  PosClaferId _ name  -> desugarName name
+  Union _ exp0 exp'        -> dop iUnion        [exp0, exp']
+  UnionCom _ exp0 exp'     -> dop iUnion        [exp0, exp']
+  Difference _ exp0 exp'   -> dop iDifference   [exp0, exp']
+  Intersection _ exp0 exp' -> dop iIntersection [exp0, exp']
+  Domain _ exp0 exp'       -> dop iDomain       [exp0, exp']
+  Range _ exp0 exp'        -> dop iRange        [exp0, exp']
+  Join _ exp0 exp'         -> dop iJoin         [exp0, exp']
+  ClaferId _ name  -> desugarName name
 
   where
   dop = desugarOp desugarSetExp
@@ -439,62 +345,62 @@ 
 sugarExp' :: IExp -> Exp
 sugarExp' x = case x of
-  IDeclPExp quant' [] pexp -> QuantExp (sugarQuant quant') (sugarExp pexp)
+  IDeclPExp quant' [] pexp -> QuantExp noSpan (sugarQuant quant') (sugarExp pexp)
   IDeclPExp IAll (decl@(IDecl True _ _):[]) pexp ->
-    DeclAllDisj   (sugarDecl decl) (sugarExp pexp)
+    DeclAllDisj noSpan (sugarDecl decl) (sugarExp pexp)
   IDeclPExp IAll  (decl@(IDecl False _ _):[]) pexp ->
-    DeclAll       (sugarDecl decl) (sugarExp pexp)
+    DeclAll noSpan (sugarDecl decl) (sugarExp pexp)
   IDeclPExp quant' (decl@(IDecl True _ _):[]) pexp ->
-    DeclQuantDisj (sugarQuant quant') (sugarDecl decl) (sugarExp pexp)
+    DeclQuantDisj noSpan (sugarQuant quant') (sugarDecl decl) (sugarExp pexp)
   IDeclPExp quant' (decl@(IDecl False _ _):[]) pexp ->
-    DeclQuant     (sugarQuant quant') (sugarDecl decl) (sugarExp pexp)
+    DeclQuant noSpan (sugarQuant quant') (sugarDecl decl) (sugarExp pexp)
   IFunExp op' exps' ->
     if op' `elem` unOps then (sugarUnOp op') (exps''!!0)
-    else if op' `elem` setBinOps then (ESetExp $ sugarSetExp' x)
+    else if op' `elem` setBinOps then (ESetExp noSpan $ sugarSetExp' x)
     else if op' `elem` binOps then (sugarOp op') (exps''!!0) (exps''!!1)
     else (sugarTerOp op') (exps''!!0) (exps''!!1) (exps''!!2)
     where
     exps'' = map sugarExp exps'
-  IInt n -> EInt $ PosInteger ((0, 0), show n)
-  IDouble n -> EDouble $ PosDouble ((0, 0), show n)
-  IStr str -> EStr $ PosString ((0, 0), str)
-  IClaferId _ _ _ -> ESetExp $ sugarSetExp' x
+  IInt n -> EInt noSpan $ PosInteger ((0, 0), show n)
+  IDouble n -> EDouble noSpan $ PosDouble ((0, 0), show n)
+  IStr str -> EStr noSpan $ PosString ((0, 0), str)
+  IClaferId _ _ _ -> ESetExp noSpan $ sugarSetExp' x
   _ -> error "Function sugarExp' from Desugarer was given an invalid argument" -- This should never happen
   where
   sugarUnOp op''
-    | op'' == iNot           = ENeg
-    | op'' == iCSet          = ECSetExp
-    | op'' == iMin           = EMinExp
-    | op'' == iGMax          = EGMax
-    | op'' == iGMin          = EGMin 
-    | op'' == iSumSet        = ESumSetExp
+    | op'' == iNot           = ENeg noSpan
+    | op'' == iCSet          = ECSetExp noSpan
+    | op'' == iMin           = EMinExp noSpan
+    | op'' == iGMax          = EGMax noSpan
+    | op'' == iGMin          = EGMin noSpan
+    | op'' == iSumSet        = ESumSetExp noSpan
     | otherwise            = error $ show op'' ++ "is not an op"
   sugarOp op''
-    | op'' == iIff           = EIff
-    | op'' == iImpl          = EImplies
-    | op'' == iOr            = EOr
-    | op'' == iXor           = EXor
-    | op'' == iAnd           = EAnd 
-    | op'' == iLt            = ELt
-    | op'' == iGt            = EGt
-    | op'' == iEq            = EEq  
-    | op'' == iLte           = ELte
-    | op'' == iGte           = EGte
-    | op'' == iNeq           = ENeq
-    | op'' == iIn            = EIn
-    | op'' == iNin           = ENin
-    | op'' == iPlus          = EAdd
-    | op'' == iSub           = ESub
-    | op'' == iMul           = EMul
-    | op'' == iDiv           = EDiv
+    | op'' == iIff           = EIff noSpan
+    | op'' == iImpl          = EImplies noSpan
+    | op'' == iOr            = EOr noSpan
+    | op'' == iXor           = EXor noSpan
+    | op'' == iAnd           = EAnd noSpan
+    | op'' == iLt            = ELt noSpan
+    | op'' == iGt            = EGt noSpan
+    | op'' == iEq            = EEq noSpan
+    | op'' == iLte           = ELte noSpan
+    | op'' == iGte           = EGte noSpan
+    | op'' == iNeq           = ENeq noSpan
+    | op'' == iIn            = EIn noSpan
+    | op'' == iNin           = ENin noSpan
+    | op'' == iPlus          = EAdd noSpan
+    | op'' == iSub           = ESub noSpan
+    | op'' == iMul           = EMul noSpan
+    | op'' == iDiv           = EDiv noSpan
     | otherwise            = error $ show op'' ++ "is not an op"
   sugarTerOp op''
-    | op'' == iIfThenElse    = EImpliesElse
+    | op'' == iIfThenElse    = EImpliesElse noSpan
     | otherwise            = error $ show op'' ++ "is not an op"
 
 
 sugarSetExp :: PExp -> SetExp
-sugarSetExp x = sugarSetExp' $ Language.Clafer.Intermediate.Intclafer._exp x
+sugarSetExp x = sugarSetExp' $ _exp x
 
 
 sugarSetExp' :: IExp -> SetExp
@@ -502,15 +408,15 @@     where
     exps'' = map sugarSetExp exps'
     sugarOp op''
-      | op'' == iUnion         = Union
-      | op'' == iDifference    = Difference
-      | op'' == iIntersection  = Intersection
-      | op'' == iDomain        = Domain
-      | op'' == iRange         = Range
-      | op'' == iJoin          = Join
+      | op'' == iUnion         = Union noSpan 
+      | op'' == iDifference    = Difference noSpan 
+      | op'' == iIntersection  = Intersection noSpan 
+      | op'' == iDomain        = Domain noSpan 
+      | op'' == iRange         = Range noSpan 
+      | op'' == iJoin          = Join noSpan 
       | otherwise              = error "Invalid argument given to function sygarSetExp' in Desugarer"
-sugarSetExp' (IClaferId "" id' _) = ClaferId $ Path [ModIdIdent $ mkIdent id']
-sugarSetExp' (IClaferId modName' id' _) = ClaferId $ Path $ (sugarModId modName') : [sugarModId id']
+sugarSetExp' (IClaferId "" id' _) = ClaferId noSpan $ Path noSpan [ModIdIdent noSpan $ mkIdent id']
+sugarSetExp' (IClaferId modName' id' _) = ClaferId noSpan $ Path noSpan $ (sugarModId modName') : [sugarModId id']
 sugarSetExp' _ = error "IDecelPexp, IInt, IDobule, and IStr can not be sugared into a setExp!" --This should never happen
 
 desugarPath :: PExp -> PExp
@@ -551,37 +457,32 @@ 
 
 desugarDecl :: Bool -> Decl -> IDecl
-desugarDecl isDisj' (Decl locids exp') = desugarDecl isDisj' $ PosDecl noSpan locids exp'
-desugarDecl isDisj' (PosDecl _ locids exp') =
+desugarDecl isDisj' (Decl _ locids exp') =
     IDecl isDisj' (map desugarLocId locids) (desugarSetExp exp')
 
 
 sugarDecl :: IDecl -> Decl
 sugarDecl (IDecl _ locids exp') =
-    Decl (map sugarLocId locids) (sugarSetExp exp')
+    Decl noSpan (map sugarLocId locids) (sugarSetExp exp')
 
 
 desugarLocId :: LocId -> String
-desugarLocId (LocIdIdent id') = desugarLocId $ PosLocIdIdent noSpan id'
-desugarLocId (PosLocIdIdent _ id') = transIdent id'
+desugarLocId (LocIdIdent _ id') = transIdent id'
 
 
 sugarLocId :: String -> LocId
-sugarLocId x = LocIdIdent $ mkIdent x
+sugarLocId x = LocIdIdent noSpan $ mkIdent x
 
 desugarQuant :: Quant -> IQuant
-desugarQuant QuantNo = desugarQuant $ PosQuantNo noSpan
-desugarQuant QuantLone = desugarQuant $ PosQuantLone noSpan
-desugarQuant QuantOne = desugarQuant $ PosQuantOne noSpan
-desugarQuant QuantSome = desugarQuant $ PosQuantSome noSpan
-desugarQuant (PosQuantNo _) = INo
-desugarQuant (PosQuantLone _) = ILone
-desugarQuant (PosQuantOne _) = IOne
-desugarQuant (PosQuantSome _) = ISome
+desugarQuant (QuantNo _) = INo
+desugarQuant (QuantNot _) = INo
+desugarQuant (QuantLone _) = ILone
+desugarQuant (QuantOne _) = IOne
+desugarQuant (QuantSome _) = ISome
 
 sugarQuant :: IQuant -> Quant
-sugarQuant INo = QuantNo
-sugarQuant ILone = QuantLone
-sugarQuant IOne = QuantOne
-sugarQuant ISome = QuantSome
+sugarQuant INo = QuantNo noSpan  -- will never sugar to QuantNOT
+sugarQuant ILone = QuantLone noSpan
+sugarQuant IOne = QuantOne noSpan
+sugarQuant ISome = QuantSome noSpan
 sugarQuant IAll = error "sugarQaunt was called on IAll, this is not allowed!" --Should never happen
src/Language/Clafer/Intermediate/GLPKScopeAnalyzer.hs view
@@ -1001,9 +1001,6 @@ 
 spanToSourcePos :: Span -> SourcePos
 spanToSourcePos (Span (Pos l c) _) = (newPos "" (fromInteger l) (fromInteger c))
-spanToSourcePos (PosSpan _ (Pos l c) _) = (newPos "" (fromInteger l) (fromInteger c))
-spanToSourcePos (Span (PosPos _ l c) _) = (newPos "" (fromInteger l) (fromInteger c))
-spanToSourcePos (PosSpan _ (PosPos _ l c) _) = (newPos "" (fromInteger l) (fromInteger c))
 
 patternMatch :: MonadScope m => ParseT m a -> ParseState -> [Token] -> m (Either ParseError a)
 patternMatch parse' state' =
src/Language/Clafer/Intermediate/ResolverInheritance.hs view
@@ -153,9 +153,6 @@     | otherwise = (0, 1)
   pGcard = _interval $ fromJust $ _gcard $ fromJust $ context env
   isTopLevel (Span (Pos _ c) _) = c==1
-  isTopLevel (Span (PosPos _ _ c) _) = c==1
-  isTopLevel (PosSpan _ (Pos _ c) _) = c==1
-  isTopLevel (PosSpan _ (PosPos _ _ c) _) = c==1
 
 analyzeElement :: SEnv -> IElement -> IElement
 analyzeElement env x = case x of
src/Language/Clafer/Intermediate/ResolverType.hs view
@@ -43,7 +43,7 @@ data TypeInfo = TypeInfo {iTypeDecls::TypeDecls, iInfo::Info, iCurThis::SClafer, iCurPath::Maybe IType}
 
 newtype TypeAnalysis a = TypeAnalysis (ReaderT TypeInfo (Either ClaferSErr) a)
-  deriving (MonadError ClaferSErr, Monad, Functor, MonadReader TypeInfo)
+  deriving (MonadError ClaferSErr, Monad, Functor, MonadReader TypeInfo, Applicative)
   
 typeOfUid :: MonadTypeAnalysis m => String -> m IType
 typeOfUid uid = (fromMaybe (TClafer [uid]) . lookup uid) <$> typeDecls
@@ -342,7 +342,7 @@                 (test (t1 == TString && t2 == TString) >> return TString) -- Case 1: String concatenation
                 `catchError`
                 const (test (numeric t1 && numeric t2) >> return (coerce t1 t2)) -- Case 2: Addition
-            | otherwise = error $ "Unknown op: " ++ show e
+            | otherwise = error $ "ResolverType: Unknown op: " ++ show e
       result' <- result
       return (result', e{_exps = [arg1', arg2']})
 
src/Language/Clafer/Intermediate/Tracing.hs view
@@ -24,7 +24,6 @@ import Data.Map (Map)
 import qualified Data.Map as Map
 import Language.Clafer.Front.Absclafer
-import Language.Clafer.Front.Mapper
 import Language.Clafer.Intermediate.Intclafer
 
 traceIrModule :: IModule -> Map Span [Ir] --Map Span [Union (IRClafer IClafer) (IRPExp PExp)]
@@ -45,60 +44,53 @@     (traverseModule x)
   where
   ins y = Map.insertWith (++) (i y) [y]
-  i (AstModule a) = range a
-  i (AstDeclaration a) = range a
-  i (AstClafer a) = range a
-  i (AstConstraint a) = range a
-  i (AstSoftConstraint a) = range a
-  i (AstGoal a) = range a
-  i (AstAbstract a) = range a
-  i (AstElements a) = range a
-  i (AstElement a) = range a
-  i (AstSuper a) = range a
-  i (AstSuperHow a) = range a
-  i (AstInit a) = range a
-  i (AstInitHow a) = range a
-  i (AstGCard a) = range a
-  i (AstCard a) = range a
-  i (AstNCard a) = range a
-  i (AstExInteger a) = range a
-  i (AstName a) = range a
-  i (AstExp a) = range a
-  i (AstSetExp a) = range a
-  i (AstDecl a) = range a
-  i (AstQuant a) = range a
-  i (AstEnumId a) = range a
-  i (AstModId a) = range a
-  i (AstLocId a) = range a
+  i (AstModule a) = getSpan a
+  i (AstDeclaration a) = getSpan a
+  i (AstClafer a) = getSpan a
+  i (AstConstraint a) = getSpan a
+  i (AstSoftConstraint a) = getSpan a
+  i (AstGoal a) = getSpan a
+  i (AstAbstract a) = getSpan a
+  i (AstElements a) = getSpan a
+  i (AstElement a) = getSpan a
+  i (AstSuper a) = getSpan a
+  i (AstSuperHow a) = getSpan a
+  i (AstInit a) = getSpan a
+  i (AstInitHow a) = getSpan a
+  i (AstGCard a) = getSpan a
+  i (AstCard a) = getSpan a
+  i (AstNCard a) = getSpan a
+  i (AstExInteger a) = getSpan a
+  i (AstName a) = getSpan a
+  i (AstExp a) = getSpan a
+  i (AstSetExp a) = getSpan a
+  i (AstDecl a) = getSpan a
+  i (AstQuant a) = getSpan a
+  i (AstEnumId a) = getSpan a
+  i (AstModId a) = getSpan a
+  i (AstLocId a) = getSpan a
 
 traverseModule :: Module -> [Ast]
-traverseModule x@(PosModule _ d) = AstModule x : concatMap traverseDeclaration d
-traverseModule x@(Module d) = AstModule x : concatMap traverseDeclaration d -- should never happen
+traverseModule x@(Module _ d) = AstModule x : concatMap traverseDeclaration d 
 
 traverseDeclaration :: Declaration -> [Ast]
 traverseDeclaration x =
   AstDeclaration x :
     case x of
-    PosEnumDecl _ _ e -> concatMap traverseEnumId e
-    PosElementDecl _ e -> traverseElement e
-    EnumDecl _ e -> concatMap traverseEnumId e  -- These bottom two should not happen
-    ElementDecl e -> traverseElement e          -- should always be given a Pos
+    EnumDecl _ _ e -> concatMap traverseEnumId e  
+    ElementDecl _ e -> traverseElement e          
 
 traverseClafer :: Clafer -> [Ast]
-traverseClafer x@(PosClafer _ a b _ d e f g) = AstClafer x : (traverseAbstract a ++ traverseGCard b ++ traverseSuper d ++ traverseCard e ++ traverseInit f ++ traverseElements g)
-traverseClafer x@(Clafer a b _ d e f g) = AstClafer x : (traverseAbstract a ++ traverseGCard b ++ traverseSuper d ++ traverseCard e ++ traverseInit f ++ traverseElements g) -- Should never happen
+traverseClafer x@(Clafer _ a b _ d e f g) = AstClafer x : (traverseAbstract a ++ traverseGCard b ++ traverseSuper d ++ traverseCard e ++ traverseInit f ++ traverseElements g)
 
 traverseConstraint :: Constraint -> [Ast]
-traverseConstraint x@(PosConstraint _ e) = AstConstraint x : concatMap traverseExp e
-traverseConstraint x@(Constraint e) = AstConstraint x : concatMap traverseExp e -- This should never happen
+traverseConstraint x@(Constraint _ e) = AstConstraint x : concatMap traverseExp e
 
 traverseSoftConstraint :: SoftConstraint -> [Ast]
-traverseSoftConstraint x@(PosSoftConstraint _ e) = AstSoftConstraint x : concatMap traverseExp e
-traverseSoftConstraint x@(SoftConstraint e) = AstSoftConstraint x : concatMap traverseExp e -- This should never happen
+traverseSoftConstraint x@(SoftConstraint _ e) = AstSoftConstraint x : concatMap traverseExp e
 
 traverseGoal :: Goal -> [Ast]
-traverseGoal x@(PosGoal _ e) = AstGoal x : concatMap traverseExp e
-traverseGoal x@(Goal e) = AstGoal x : concatMap traverseExp e -- This should never happen
+traverseGoal x@(Goal _ e) = AstGoal x : concatMap traverseExp e
 
 traverseAbstract :: Abstract -> [Ast]
 traverseAbstract x =
@@ -108,34 +100,25 @@ traverseElements x =
   AstElements x :
     case x of
-    PosElementsEmpty _ -> []
-    PosElementsList _ e -> concatMap traverseElement e
-    ElementsEmpty -> [] -- These bottom two should not happen, should always be given a Pos
-    ElementsList e -> concatMap traverseElement e
+    ElementsEmpty _ -> []
+    ElementsList _ e -> concatMap traverseElement e
 
 traverseElement :: Element -> [Ast]
 traverseElement x =
   AstElement x :
     case x of
-    PosSubclafer _ c -> traverseClafer c
-    PosClaferUse _ n c e -> traverseName n ++ traverseCard c ++ traverseElements e
-    PosSubconstraint _ c -> traverseConstraint c
-    PosSubgoal _ g -> traverseGoal g
-    PosSubsoftconstraint _ c -> traverseSoftConstraint c
-    Subclafer c -> traverseClafer c                                           -- This and bellow should never happen
-    ClaferUse n c e -> traverseName n ++ traverseCard c ++ traverseElements e -- should always be given a Pos
-    Subconstraint c -> traverseConstraint c
-    Subgoal g -> traverseGoal g
-    Subsoftconstraint c -> traverseSoftConstraint c
+    Subclafer _ c -> traverseClafer c
+    ClaferUse _ n c e -> traverseName n ++ traverseCard c ++ traverseElements e
+    Subconstraint _ c -> traverseConstraint c
+    Subgoal _ g -> traverseGoal g
+    Subsoftconstraint _ c -> traverseSoftConstraint c
 
 traverseSuper :: Super -> [Ast]
 traverseSuper x =
   AstSuper x :
     case x of
-    PosSuperEmpty _ -> []
-    PosSuperSome _ sh se -> traverseSuperHow sh ++ traverseSetExp se
-    SuperEmpty -> [] -- These bottom two should not happen, should always be given a Pos
-    SuperSome sh se -> traverseSuperHow sh ++ traverseSetExp se
+    SuperEmpty _ -> []
+    SuperSome _ sh se -> traverseSuperHow sh ++ traverseSetExp se
 
 traverseSuperHow :: SuperHow -> [Ast]
 traverseSuperHow x =
@@ -145,10 +128,8 @@ traverseInit x =
   AstInit x :
     case x of
-    PosInitEmpty _ -> []
-    PosInitSome _ ih e -> traverseInitHow ih ++ traverseExp e
-    InitEmpty -> [] -- These bottom two should not happen, should always be given a Pos
-    InitSome ih e -> traverseInitHow ih ++ traverseExp e
+    InitEmpty _ -> []
+    InitSome _ ih e -> traverseInitHow ih ++ traverseExp e
 
 traverseInitHow :: InitHow -> [Ast]
 traverseInitHow x =
@@ -158,144 +139,88 @@ traverseGCard x =
   AstGCard x :
     case x of
-    PosGCardEmpty _ -> []
-    PosGCardXor _ -> []
-    PosGCardOr _ -> []
-    PosGCardMux _ -> []
-    PosGCardOpt _ -> []
-    PosGCardInterval _ n -> traverseNCard n
-    GCardEmpty -> [] -- This and bellow should not happen
-    GCardXor -> []   -- should always be given a Pos
-    GCardOr -> []
-    GCardMux -> []
-    GCardOpt -> []
-    GCardInterval n -> traverseNCard n
+    GCardEmpty _ -> []
+    GCardXor _ -> []
+    GCardOr _ -> []
+    GCardMux _ -> []
+    GCardOpt _ -> []
+    GCardInterval _ n -> traverseNCard n
 
 traverseCard :: Card -> [Ast]
 traverseCard x =
   AstCard x :
     case x of
-    PosCardEmpty _ -> []
-    PosCardLone _ -> []
-    PosCardSome _ -> []
-    PosCardAny _ -> []
-    PosCardNum _ _ -> []
-    PosCardInterval _ n -> traverseNCard n
-    CardEmpty -> [] -- This and Bellow Should not happen
-    CardLone -> []  -- Should always been given a Pos
-    CardSome -> []
-    CardAny -> []
-    CardNum _ -> []
-    CardInterval n -> traverseNCard n
+    CardEmpty _ -> []
+    CardLone _ -> []
+    CardSome _ -> []
+    CardAny _ -> []
+    CardNum _ _ -> []
+    CardInterval _ n -> traverseNCard n
 
 traverseNCard :: NCard -> [Ast]
-traverseNCard x@(PosNCard _ _ e) = AstNCard x : traverseExInteger e
-traverseNCard x@(NCard _ e) = AstNCard x : traverseExInteger e -- Should never happen
+traverseNCard x@(NCard _ _ e) = AstNCard x : traverseExInteger e
 
 traverseExInteger :: ExInteger -> [Ast]
 traverseExInteger x =
   AstExInteger x : [{- no other children -}]
 
 traverseName :: Name -> [Ast]
-traverseName x@(PosPath _ m) = AstName x : concatMap traverseModId m
-traverseName x@(Path m) = AstName x : concatMap traverseModId m -- Should never happen
+traverseName x@(Path _ m) = AstName x : concatMap traverseModId m
 
 traverseExp :: Exp -> [Ast]
 traverseExp x =
   AstExp x :
     case x of
-    PosDeclAllDisj _ d e -> traverseDecl d ++ traverseExp e
-    PosDeclAll _ d e -> traverseDecl d ++ traverseExp e
-    PosDeclQuantDisj _ q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
-    PosDeclQuant _ q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
-    PosEGMax _ e -> traverseExp e
-    PosEGMin _ e -> traverseExp e
-    PosEIff _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEImplies _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEOr _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEXor _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEAnd _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosENeg _ e -> traverseExp e
-    PosELt _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEGt _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEEq _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosELte _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEGte _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosENeq _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEIn _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosENin _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosQuantExp _ q e -> traverseQuant q ++ traverseExp e
-    PosEAdd _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosESub _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEMul _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosEDiv _ e1 e2 -> traverseExp e1 ++ traverseExp e2
-    PosECSetExp _ e -> traverseExp e
-    PosEMinExp _ e -> traverseExp e
-    PosEImpliesElse _ e1 e2 e3 -> traverseExp e1 ++ traverseExp e2 ++ traverseExp e3
-    PosEInt _ _ -> []
-    PosEDouble _ _ -> []
-    PosEStr _ _ -> []
-    PosESetExp _ s -> traverseSetExp s
-    DeclAllDisj d e -> traverseDecl d ++ traverseExp e                        -- This and Bellow should not happen
-    DeclAll d e -> traverseDecl d ++ traverseExp e                            -- Should always be given a Pos
-    DeclQuantDisj q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
-    DeclQuant q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
-    EGMax e -> traverseExp e
-    EGMin e -> traverseExp e
-    EIff e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EImplies e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EOr e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EXor e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EAnd e1 e2 -> traverseExp e1 ++ traverseExp e2
-    ENeg e -> traverseExp e
-    ELt e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EGt e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EEq e1 e2 -> traverseExp e1 ++ traverseExp e2
-    ELte e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EGte e1 e2 -> traverseExp e1 ++ traverseExp e2
-    ENeq e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EIn e1 e2 -> traverseExp e1 ++ traverseExp e2
-    ENin e1 e2 -> traverseExp e1 ++ traverseExp e2
-    QuantExp q e -> traverseQuant q ++ traverseExp e
-    EAdd e1 e2 -> traverseExp e1 ++ traverseExp e2
-    ESub e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EMul e1 e2 -> traverseExp e1 ++ traverseExp e2
-    EDiv e1 e2 -> traverseExp e1 ++ traverseExp e2
-    ECSetExp e -> traverseExp e
-    EMinExp e -> traverseExp e
-    EImpliesElse e1 e2 e3 -> traverseExp e1 ++ traverseExp e2 ++ traverseExp e3
-    EInt _ -> []
-    EDouble _ -> []
-    EStr _ -> []
-    ESetExp s -> traverseSetExp s
-    _ -> error "Invalid argument given to function traverseExp from Tracing" -- Should never happen
+    DeclAllDisj _ d e -> traverseDecl d ++ traverseExp e
+    DeclAll _ d e -> traverseDecl d ++ traverseExp e
+    DeclQuantDisj _ q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
+    DeclQuant _ q d e -> traverseQuant q ++ traverseDecl d ++ traverseExp e
+    EGMax _ e -> traverseExp e
+    EGMin _ e -> traverseExp e
+    EIff _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EImplies _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EOr _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EXor _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EAnd _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    ENeg _ e -> traverseExp e
+    ELt _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EGt _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EEq _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    ELte _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EGte _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    ENeq _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EIn _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    ENin _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    QuantExp _ q e -> traverseQuant q ++ traverseExp e
+    EAdd _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    ESub _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EMul _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    EDiv _ e1 e2 -> traverseExp e1 ++ traverseExp e2
+    ECSetExp _ e -> traverseExp e
+    EMinExp _ e -> traverseExp e
+    EImpliesElse _ e1 e2 e3 -> traverseExp e1 ++ traverseExp e2 ++ traverseExp e3
+    EInt _ _ -> []
+    EDouble _ _ -> []
+    EStr _ _ -> []
+    ESetExp _ s -> traverseSetExp s
+    _ -> error "Invalid argument given to function traverseExp from Tracing" 
 
 traverseSetExp :: SetExp -> [Ast]
 traverseSetExp x =
   AstSetExp x :
     case x of
-    PosUnion _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosUnionCom _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosDifference _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosIntersection _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosDomain _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosRange _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosJoin _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    PosClaferId _ n -> traverseName n
-    Union s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2    -- This and Bellow Should not happen
-    UnionCom s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2 -- It should also be given a Pos
-    Difference s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    Intersection s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    Domain s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    Range s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    Join s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
-    ClaferId n -> traverseName n
-
+    Union _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    UnionCom _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    Difference _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    Intersection _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    Domain _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    Range _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    Join _ s1 s2 -> traverseSetExp s1 ++ traverseSetExp s2
+    ClaferId _ n -> traverseName n
+    
 traverseDecl :: Decl -> [Ast]
-traverseDecl x@(PosDecl _ l s) =
+traverseDecl x@(Decl _ l s) =
   AstDecl x : (concatMap traverseLocId l ++ traverseSetExp s)
-traverseDecl x@(Decl l s) = 
-  AstDecl x : (concatMap traverseLocId l ++ traverseSetExp s) -- Should never happen
 
 traverseQuant :: Quant -> [Ast]
 traverseQuant x =
src/Language/ClaferT.hs view
@@ -242,22 +242,18 @@       let pos' = ((Pos 1 1 : f) !! frgId) `addPos` frgPos
       return $ ErrPos frgId frgPos pos'
   toErrPos (ErrFragSpan frgId (Span frgPos _)) = toErrPos $ ErrFragPos frgId frgPos
-  toErrPos (ErrFragSpan frgId (PosSpan _ frgPos _)) = toErrPos $ ErrFragPos frgId frgPos -- Should never happen
   toErrPos (ErrModelPos modelPos') =
     do
       f <- getsEnv frags
       let fragSpans = zipWith Span (Pos 1 1 : f) f
       case findFrag modelPos' fragSpans of
         Just (frgId, Span fragStart _) -> return $ ErrPos frgId (modelPos' `minusPos` fragStart) modelPos'
-        Just (frgId, PosSpan _ fragStart _) -> return $ ErrPos frgId (modelPos' `minusPos` fragStart) modelPos'
         Nothing -> error $ show modelPos' ++ " not within any frag spans: " ++ show fragSpans -- Indicates a bug in the Clafer translator
     where
     findFrag pos'' spans =
       find (inSpan pos'' . snd) (zip [0..] spans)
   toErrPos (ErrModelSpan (Span modelPos'' _)) = toErrPos $ ErrModelPos modelPos''
-  toErrPos (ErrModelSpan (PosSpan _ modelPos'' _)) = toErrPos $ ErrModelPos modelPos'' -- Should never happen
 
-
 class Throwable t where
   toErr :: t -> Monad m => ClaferT m ClaferErr
   
@@ -286,17 +282,12 @@ addPos :: Pos -> Pos -> Pos
 addPos (Pos l c) (Pos 1 d) = Pos l (c + d - 1)    -- Same line
 addPos (Pos l _) (Pos m d) = Pos (l + m - 1) d    -- Different line
-addPos pos' (PosPos _ l c) = addPos pos' (Pos l c)
-addPos (PosPos _ l c) pos' = addPos (Pos l c) pos'
 minusPos :: Pos -> Pos -> Pos
 minusPos (Pos l c) (Pos 1 d) = Pos l (c - d + 1)  -- Same line
 minusPos (Pos l c) (Pos m _) = Pos (l - m + 1) c  -- Different line
-minusPos pos' (PosPos _ l c) = minusPos pos' (Pos l c)
-minusPos (PosPos _ l c) pos' = minusPos (Pos l c) pos'
 
 inSpan :: Pos -> Span -> Bool
 inSpan pos' (Span start end) = pos' >= start && pos' <= end
-inSpan pos' (PosSpan _ s e)  = inSpan pos' (Span s e)
 
 -- | Get the ClaferEnv
 getEnv :: Monad m => ClaferT m ClaferEnv
− src/clafer.hs
@@ -1,209 +0,0 @@-{-
- Copyright (C) 2012-2014 Kacper Bak, Jimmy Liang, Michal Antkiewicz <http://gsd.uwaterloo.ca>
-
- Permission is hereby granted, free of charge, to any person obtaining a copy of
- this software and associated documentation files (the "Software"), to deal in
- the Software without restriction, including without limitation the rights to
- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
- of the Software, and to permit persons to whom the Software is furnished to do
- so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all
- copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
--}
-{-# LANGUAGE DeriveDataTypeable #-}
-module Main where
-
-import Prelude hiding (writeFile, readFile, print, putStrLn)
-import qualified Data.Map as Map
-import qualified Data.List as List
-import Data.List.Split
-import Data.Maybe
-import Control.Monad.State
-import System.IO
-import System.Cmd
-import System.Exit
-import System.Timeout
-import System.FilePath (dropExtension,takeBaseName)
-import System.Process (readProcessWithExitCode)
-
-import Paths_clafer
-import Language.Clafer
-import Language.ClaferT
-import Language.Clafer.Css
-import Language.Clafer.ClaferArgs
-import Language.Clafer.JSONMetaData
-import Language.Clafer.QNameUID
-import Language.Clafer.Intermediate.Intclafer
-import Language.Clafer.Generator.Html (highlightErrors)
-import Language.Clafer.Generator.Graph (genSimpleGraph)
-
-putStrV :: VerbosityL -> String -> IO ()
-putStrV v s = if v > 1 then putStrLn s else return ()
-
-run :: VerbosityL -> ClaferArgs -> InputModel -> IO ()
-run _ args' input =
-  do
-    result <- runClaferT args' $
-      do
-        addFragments $ fragments input
-        parse
-        compile
-        fs <- save args'
-        when (validate args') $ forM_ fs (liftIO . runValidate args' )
-    if Html `elem` (mode args')
-      then htmlCatch result args' input
-      else return ()
-    result `cth` handleErrs
-  where
-  cth (Left err) f = f err
-  cth (Right r)  _ = return r
-  addFragments []     = return ()
-  addFragments (x:xs) = addModuleFragment x >> addFragments xs
-  fragments model = map unlines $ fragments' $ lines model
-  fragments' []                  = []
-  fragments' ("//# FRAGMENT":xs) = fragments' xs
-  fragments' model               = takeWhile (/= "//# FRAGMENT") model : fragments' (dropWhile (/= "//# FRAGMENT") model)
---  htmlCatch :: Either ClaferErr CompilerResult -> ClaferArgs -> String -> IO(CompilerResult)
-  htmlCatch (Right r) _ _ = return r
-  htmlCatch (Left err) args'' model =
-    do let f = (dropExtension $ file args'') ++ ".html"
-       let result = (if (self_contained args'') then header ++ "<style>" ++ css ++ "</style>" ++ "</head>\n<body>\n<pre>\n" else "") ++ highlightErrors model err ++
-                                                               (if (self_contained args'') then "\n</pre>\n</html>" else "")
-       liftIO $ if console_output args'' then putStrLn result else writeFile f result
-  
-  handleErrs = mapM_ handleErr
-  handleErr (ClaferErr mesg) =
-    do
-      putStrLn "\nError...\n"
-      putStrLn mesg
-      exitFailure
-  -- We only use one fragment. Fragment id and position is not useful to us. We
-  -- only care about the position relative to 
-  handleErr (ParseErr ErrPos{modelPos = Pos l c} mesg) =
-    do
-      putStrLn $ "\nParse failed at line " ++ show l ++ " column " ++ show c ++ "..."
-      putStrLn mesg
-      exitFailure
-  handleErr (SemanticErr ErrPos{modelPos = Pos l c} mesg) =
-    do
-      putStrLn $ "\nCompile error at line " ++ show l ++ " column " ++ show c ++ "..."
-      putStrLn mesg
-      exitFailure
-  handleErr _ = error "Function handleErr from Main file was given an invalid argument"
-
-save :: MonadIO m => ClaferArgs -> ClaferT m [ String ]
-save args'=
-  do
-    resultsMap <- generate
-    let results = snd $ List.unzip $ Map.toList resultsMap
-    -- print stats only once
-    when (not $ no_stats args') $ liftIO $ printStats results
-    -- save the outputs
-    (iModule, _, _) <- getIr
-    forM results $ \result -> do
-      result' <- if (add_graph args') && (Html `elem` (mode args') && ("dot" `List.isSuffixOf` (extension result))) 
-            then do
-                   ast' <- getAst
-                   (_, graph, _) <- liftIO $ readProcessWithExitCode "dot"  ["-Tsvg"] $ genSimpleGraph ast' iModule (takeBaseName $ file args') (show_references args')
-                   return $ summary graph result
-            else return result
-      let f = dropExtension $ file args'
-      let f' = f ++ "." ++ (extension result)
-      liftIO $ if console_output args' then putStrLn (outputCode result') else writeFile f' (outputCode result')
-      liftIO $ when (alloy_mapping args') $ writeFile (f ++ ".map") $ show (mappingToAlloy result')
-      let 
-        qNameMaps :: QNameMaps
-        qNameMaps = deriveQNameMaps iModule
-      liftIO $ when (meta_data args') $ writeFile (f ++ ".cfr-map") $ generateJSONnameUIDMap qNameMaps
-      liftIO $ when (meta_data args' && inScopeModes) $ writeFile (f ++ ".cfr-scope") $ generateJSONScopes qNameMaps $ getScopesList resultsMap
-      return f'  
-  where
-    printStats :: [CompilerResult] -> IO ()
-    printStats []         = putStrLn "No compiler output."
-    printStats (r:_) = putStrLn (statistics r)
-
-    inScopeModes :: Bool
-    inScopeModes = 
-      Alloy `elem` mode args' ||
-      Alloy42 `elem` mode args' ||
-      Choco `elem` mode args'
-
-    getScopesList :: (Map.Map ClaferMode CompilerResult) -> [(UID, Integer)]
-    getScopesList    resultsMap =
-        let
-           alloyResult = Map.lookup Alloy resultsMap
-           alloy42Result = Map.lookup Alloy42 resultsMap
-           chocoResult = Map.lookup Choco resultsMap
-        in 
-           if (isNothing alloyResult)
-           then if (isNothing alloy42Result)
-                then if (isNothing chocoResult)
-                     then []
-                     else scopesList $ fromJust chocoResult
-                else scopesList $ fromJust alloy42Result
-           else scopesList $ fromJust alloyResult
-
-summary :: String -> CompilerResult -> CompilerResult
-summary graph result = result{outputCode=unlines $ summary' graph ("<pre>" ++ statistics result ++ "</pre>") (lines $ outputCode result)}
-
-summary' :: String -> String -> [String] -> [String]
-summary' _ _ [] = []
-summary' graph stats ("<!-- # SUMMARY /-->":xs) = graph:stats:summary' graph stats xs
-summary' graph stats ("<!-- # STATS /-->":xs) = stats:summary' graph stats xs
-summary' graph stats ("<!-- # GRAPH /-->":xs) = graph:summary' graph stats xs
-summary' graph stats ("<!-- # CVLGRAPH /-->":xs) = graph:summary' graph stats xs
-summary' graph stats (x:xs) = x:summary' graph stats xs
-
-conPutStrLn :: ClaferArgs -> String -> IO ()
-conPutStrLn args' s = when (not $ console_output args') $ putStrLn s
-
-runValidate :: ClaferArgs -> String -> IO ()
-runValidate args' fo = do
-  let path = (tooldir args') ++ "/"
-  liftIO $ putStrLn ("Validating '" ++ fo ++"'")
-  let modes = mode args' 
-  when (Xml `elem` modes && "xml" `List.isSuffixOf` fo) $ do
-      writeFile "ClaferIR.xsd" claferIRXSD
-      voidf $ system $ "java -classpath " ++ path ++ " XsdCheck ClaferIR.xsd " ++ fo
-  when (Alloy `elem` modes && "als" `List.isSuffixOf` fo) $ do
-    voidf $ system $ validateAlloy path "4" ++ fo
-  when (Alloy42 `elem` modes && "als4" `List.isSuffixOf` fo) $ do
-    voidf $ system $ validateAlloy path "4.2" ++ fo
-  when (Clafer `elem` modes && "des.cfr" `List.isSuffixOf` fo) $ do  
-    voidf $ system $ "../dist/build/clafer/clafer -s -m=clafer " ++ fo
-
-validateAlloy :: String -> String -> String
-validateAlloy path version = "java -cp " ++ path ++ "alloy" ++ version ++ ".jar edu.mit.csail.sdg.alloy4whole.ExampleUsingTheCompiler "
-
-main :: IO ()
-main = do
-  (args', model) <- mainArgs
-  let timeInSec = (timeout_analysis args') * 10^(6::Integer)
-  if timeInSec > 0
-    then timeout timeInSec $ start 2 args' model
-    else Just `liftM` start 2 args' model
-  return ()
-
-start :: VerbosityL -> ClaferArgs -> InputModel-> IO ()
-start v args' model = if schema args'
-  then putStrLn claferIRXSD
-  else if ecore2clafer args'
-    then runEcore2Clafer (file args') $ (tooldir args')
-    else run v args' model
-
-runEcore2Clafer :: FilePath -> FilePath -> IO ()
-runEcore2Clafer    ecoreFile toolPath
-  | null ecoreFile = do
-      putStrLn "Error: Provide a file name of an ECore model."
-  | otherwise      = do
-      putStrLn $ "Converting " ++ ecoreFile ++ " into Clafer"
-      voidf $ system $ "java -jar " ++ toolPath ++ "/ecore2clafer.jar " ++ ecoreFile
test/Suite/Negative.hs view
@@ -24,13 +24,12 @@ 
 import Functions
 import Control.Monad
-import qualified Test.Framework as T
-import Test.Framework.TH
-import Test.Framework.Providers.HUnit
-import Test.HUnit
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.TH
 import Language.Clafer.ClaferArgs
 
-tg_Test_Suite_Negative :: T.Test
+tg_Test_Suite_Negative :: TestTree
 tg_Test_Suite_Negative = $(testGroupGenerator)
 
 negativeClaferModels :: IO [([Char], String)]
test/Suite/Positive.hs view
@@ -29,13 +29,12 @@ import Control.Monad
 import Language.Clafer
 import Language.ClaferT
-import qualified Test.Framework as T
-import Test.Framework.TH
-import Test.Framework.Providers.HUnit
-import Test.HUnit
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.TH
 import qualified Data.Map as Map
 
-tg_Test_Suite_Positive :: T.Test
+tg_Test_Suite_Positive :: TestTree
 tg_Test_Suite_Positive = $(testGroupGenerator)
  
 positiveClaferModels :: IO [(String, String)]
@@ -72,13 +71,11 @@ 		@? "nonempty card test failed. Files contain empty cardinalities after fully compiling")
 	where
 		getIR (file', (Right (resultMap))) = 
-			let
-				CompilerResult{claferEnv = ClaferEnv{cIr = Just (iMod, _, _)}} = fromJust $ Map.lookup Alloy resultMap
-			in
-				[(file', iMod)]
+			case Map.lookup Alloy resultMap of
+				Just CompilerResult{claferEnv = ClaferEnv{cIr = Just (iMod, _, _)}} -> [(file', iMod)]
+				_ -> []
 		getIR (_, _) = []
 		isEmptyCard (IRClafer (IClafer{_cinPos=(Span (Pos l c) _), _card = Nothing})) = "Line " ++ show l ++ " column " ++ show c ++ "\n"
-		isEmptyCard (IRClafer (IClafer{_cinPos=(PosSpan _ (Pos l c) _), _card = Nothing})) = "Line " ++ show l ++ " column " ++ show c ++ "\n"
 		isEmptyCard	_ = ""
 
 case_stringEqual :: Assertion
test/Suite/SimpleScopeAnalyser.hs view
@@ -24,20 +24,18 @@ 
 import Language.Clafer
 import Language.Clafer.Intermediate.Intclafer
-import Language.Clafer.Intermediate.SimpleScopeAnalyzer
 import Language.Clafer.JSONMetaData
 import Language.Clafer.QNameUID
 import Functions
 
 import qualified Data.Map as M
 
-import qualified Test.Framework as T
-import Test.Framework.TH
-import Test.Framework.Providers.HUnit
-import Test.HUnit
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.TH
 
 
-tg_Test_Suite_SimpleScopeAnalyser :: T.Test
+tg_Test_Suite_SimpleScopeAnalyser :: TestTree
 tg_Test_Suite_SimpleScopeAnalyser = $(testGroupGenerator)
  
 model :: String
test/test-suite.hs view
@@ -21,9 +21,7 @@  SOFTWARE.
 -}
 import Control.Lens
-import Data.Data
 import Data.Data.Lens
-import Data.Typeable
 import Data.List
 import qualified Data.Map as Map
 import Data.Maybe
@@ -35,14 +33,16 @@ import Suite.Negative
 import Suite.SimpleScopeAnalyser
 import Functions
-import Test.HUnit
-import Test.Framework
-import Test.Framework.TH
-import Test.Framework.Providers.HUnit
+import Test.Tasty
+import Test.Tasty.HUnit
+import Test.Tasty.TH
 
+tg_Main_Test_Suite :: TestTree
 tg_Main_Test_Suite = $(testGroupGenerator)
-main = defaultMain[tg_Main_Test_Suite, tg_Test_Suite_Positive, tg_Test_Suite_Negative, tg_Test_Suite_SimpleScopeAnalyser]
 
+main :: IO ()
+main = defaultMain $ testGroup "Tests" [tg_Main_Test_Suite, tg_Test_Suite_Positive, tg_Test_Suite_Negative, tg_Test_Suite_SimpleScopeAnalyser]
+
 {-
 a            // ::a -> c0_a
     b        // ::a::b -> c0_b
@@ -61,6 +61,7 @@ 
 a\n    b\nb\nc\n    d\n         b\nd\n    b
 -}
+model :: String
 model = "a\n    b\nb\nc\n    d\n         b\nd\n    b"
 
 case_FQMapLookup :: Assertion
tools/Makefile view
@@ -1,7 +1,7 @@ WGET_COMMAND := wget
 ifeq ($(OS),Windows_NT)
 	ifeq ($(shell which wget), which: wget: unkown command)
-		mingw-get install msys-wget-bin
+		pacman -S make wget
 	endif
 else
 	UNAME_S := $(shell uname -s)
@@ -18,7 +18,8 @@ 
 	@if test ! -f "alloy4.2.jar"; then \
 		echo "[WARNING] Missing alloy4.2.jar. Downloading...";  \
-		$(WGET_COMMAND) http://alloy.mit.edu/alloy/downloads/alloy4.2.jar; \
+		$(WGET_COMMAND) http://alloy.mit.edu/alloy/downloads/alloy4.2_2014-05-16.jar; \
+		mv alloy4.2_2014-05-16.jar alloy4.2.jar; \
 	fi
 
 	javac -source 1.6 -target 1.6 XsdCheck.java